a Code for the Combination of Indirect and Direct Constraints on High Energy Physics Models Logo
StandardModel Class Reference

A model class for the Standard Model. More...

#include <StandardModel.h>

+ Inheritance diagram for StandardModel:

Detailed Description

A model class for the Standard Model.

Author
HEPfit Collaboration

This is a Model class containing parameters and functions associated with the Standard Model. This class is inherited from the QCD class, which defines parameters related to QCD.

Initialization

The constructor StandardModel() initializes some of the model flags to their default values. After creating an instance of the current class, it is required to call the initialization method InitializeModel(), which allocates memory to the pointers defined in the current class. These pointers are then used in computing EW precision and flavour observables, respectively. In the Monte Carlo run, the constructor as well as the initialization method are called in InputParser::ReadParameters().

The initializations and updates of the model parameters and flags are explained below.

Model parameters

The model parameters of StandardModel are summarized below:

Label LaTeX symbol Description
Mz \(M_Z\) The mass of the \(Z\) boson in GeV.
Mw_inp \(M_W\) The mass of the \(W\) boson in GeV. Only used if the flag MWinput is TRUE.
AlsMz \(\alpha_s(M_Z)\) The strong coupling constant at the Z-boson mass.
GF \(G_\mu\) The Fermi constant in \({\rm GeV}^{-2}\), measured through muon decays.
ale \(\alpha\) The fine-structure constant.
dAle5Mz \(\Delta\alpha_{\mathrm{had}}^{(5)}(M_Z^2)\) The five-flavour hadronic contribution to the electromagnetic coupling.
mHl \(m_h\) The Higgs mass in GeV.
delMw \(\delta\,M_W\) The theoretical uncertainty in \(M_W\) in GeV, which is applicable only when EWSMApproximateFormulae::Mw() is employed for \(M_W\). See also the model flag Mw.
delSin2th_l \(\delta\sin^2\theta_{\rm eff}^{\rm lept}\) The theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{\rm lept}\), which is applicable only when EWSMApproximateFormulae::sin2thetaEff_l() is employed for \(\sin^2\theta_{\rm eff}^{\rm lept}\). See also the model flag KappaZ.
delSin2th_q \(\delta\sin^2\theta_{\rm eff}^{q\not = b,t}\) The theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{q\not = b,t}\), which is applicable only when EWSMApproximateFormulae::sin2thetaEff_q() is employed for \(\sin^2\theta_{\rm eff}^{q\not = b,t}\). See also the model flag KappaZ.
delSin2th_b \(\delta\sin^2\theta_{\rm eff}^{b}\) The theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{b}\), which is applicable only when EWSMApproximateFormulae::sin2thetaEff_b() is employed for \(\sin^2\theta_{\rm eff}^{b}\). See also the model flag KappaZ.
delGammaZ \(\delta\,\Gamma_Z\) The theoretical uncertainty in \(\Gamma_Z\) in GeV, which is applicable only when EWSMApproximateFormulae::X_full_2_loop() is employed for \(\Gamma_Z\). See also the model flag NoApproximateGammaZ.
delsigma0H \(\delta\,\sigma_{Hadron}^0\) The theoretical uncertainty in \(\sigma_{Hadron}^0\), which is applicable only when EWSMApproximateFormulae::X_full_2_loop() is employed for \(\sigma_{Hadron}^0\).
delR0l \(\delta\,R_l^0\) The theoretical uncertainty in \(R_l^0\), which is applicable only when EWSMApproximateFormulae::X_full_2_loop() is employed for \(R_l^0\).
delR0c \(\delta\,R_c^0\) The theoretical uncertainty in \(R_c^0\), which is applicable only when EWSMApproximateFormulae::X_full_2_loop() is employed for \(R_c^0\).
delR0b \(\delta\,R_b^0\) The theoretical uncertainty in \(R_b^0\), which is applicable only when EWSMApproximateFormulae::X_full_2_loop() is employed for \(R_b^0\).
mneutrino_1 \(m_{\nu_1}\) The mass of the first-generation neutrino in GeV.
mneutrino_2 \(m_{\nu_2}\) The mass of the second-generation neutrino in GeV.
mneutrino_3 \(m_{\nu_3}\) The mass of the third-generation neutrino in GeV.
melectron \(m_e\) The electron mass in GeV.
mmu \(m_\mu\) The muon mass in GeV.
mtau \(m_\tau\) The tau mass in GeV.
lambda \(\lambda\) The CKM parameter \(\lambda\) in the Wolfenstein parameterization.
A \(A\) The CKM parameter \(A\) in the Wolfenstein parameterization.
rhob \(\bar{\rho}\) The CKM parameter \(\bar{\rho}\) in the Wolfenstein parameterization.
etab \(\bar{\eta}\) The CKM parameter \(\bar{\eta}\) in the Wolfenstein parameterization.
muw \(\mu_W\) A matching scale around the weak scale in GeV.

The set of the model parameters are initialized and updated with the methods Init() and Update(), respectively, where the former calls the latter actually. In Update(), the methods PreUpdate() and PostUpdate() are called to run all the procedures that are need to be executed before and after the model parameters are updated. The CKM and PMNS matrices and the Yukawa matrices are recomputed in PostUpdate() with the updated parameters. Inside the Update() method, the individual model parameter is assigned with the protected member function setParameter().

The parameters delMw, delSin2th_l, delSin2th_q, delSin2th_b, delGammaZ, delsigma0H, delR0l, delR0c, delR0b represent theoretical uncertainties in the \(W\)-boson mass, the leptonic and quark effective weak mixing angles at the \(Z\)-boson mass scale, the total decay width of the \(Z\) boson, the hadronic cross section at the peak, and the ratios \(R_l^0\), \(R_c^0\) and \(R_b^0\), respectively, originating from missing higher-order corrections. The contributions from these parameters are incorporated into their two-loop approximate formulae: EWSMApproximateFormulae::Mw(), EWSMApproximateFormulae::sin2thetaEff_l(), EWSMApproximateFormulae::sin2thetaEff_q(), EWSMApproximateFormulae::sin2thetaEff_b(), EWSMApproximateFormulae::X_full_2_loop("GammaZ"), EWSMApproximateFormulae::X_full_2_loop("sigmaHadron"), EWSMApproximateFormulae::X_full_2_loop("R0_lepton"), EWSMApproximateFormulae::X_full_2_loop("R0_charm") and EWSMApproximateFormulae::X_full_2_loop("R0_bottom"). Therefore, the parameters are applicable only when the corresponding approximate formulae are employed. See also the model flags below.

Model flags

The flags of StandardModel are summarized below, where the values of the boolean flags (TRUE or FALSE) are case insensitive, while those of the other flags are case sensitive. The default values of the flags are indicated in bold:

Label Value Description
Wolfenstein TRUE / FALSE This flag controls the way the CKM matrix is parameterized. If set to TRUE, the CKM matrix is computed starting from the Wolfenstein parameters. If set to FALSE, the CKM matrix is computed starting from \(\vert V_{us} \vert\), \(\vert V_{cb} \vert\), \(\vert V_{ub} \vert\) and \(\gamma\). The default value is TRUE.
UseVud FALSE / TRUE This flag controls the way the CKM matrix is parameterized. If set to FALSE, with Wolfenstein FALSE, the CKM matrix is computed starting from \(\vert V_{us} \vert\), \(\vert V_{cb} \vert\), \(\vert V_{ub} \vert\) and \(\gamma\). If set to TRUE, with Wolfenstein FALSE, the CKM matrix is computed starting from \(\vert V_{ud} \vert\), \(\vert V_{cb} \vert\), \(\vert V_{ub} \vert\) and \(\gamma\). If Wolfenstein is set to TRUE, this flag has no effect. The default value is FALSE.
FixMuwMut FALSE / TRUE This flag controls the way the weak matching scale and the top quark decoupling scale are varied. If set to FALSE, the \(\mu_W\) parameter is introduced to float the matching scale independently of the top decoupling scale \(\mu_t\). If set to TRUE, the \(\mu_t\) parameter is fixed to \(\mu_W / M_W * \m_t\) Notice that in this case the \(\mu_t\) parameter defined in QCD becomes irrelevant, therefore it is advisable to fix it to a constant in the configuration file The default value is FALSE.
CacheInStandardModel TRUE / FALSE This flag controls the use of the cashing method implemented in EWSM class. The default value is TRUE.
CacheInEWSMcache TRUE / FALSE This flag controls the use of the cashing method implemented in EWSMcache class. The default value is TRUE.
WithoutNonUniversalVC TRUE / FALSE This flag controls if flavour non-universal vertex corrections are not added to the epsilon parameterization for the EW precision observables. The default value is FALSE; the non-universal corrections are taken into account.
NoApproximateGammaZ TRUE / FALSE This flag is set to true if the two-loop approximate formulae of the partial and total decay widths of the \(Z\) boson defined with the function EWSMApproximateFormulae::X_full_2_loop() are NOT employed. The default value is FALSE.
Mw NORESUM / OMSI / INTERMEDIATE / OMSII / APPROXIMATEFORMULA This flag controls the formula used in computing the \(W\)-boson mass. The default flag is APPROXIMATEFORMULA. See EWSM::Mw_SM(), EWSM::resumMw() and EWSMApproximateFormulae::Mw() for detail.
RhoZ NORESUM / OMSI / INTERMEDIATE / OMSII This flag controls the formula used in computing the \(Zf\bar{f}\) couplings \(\rho_Z^f\). The default flag is NORESUM. See EWSM::rhoZ_l_SM(), EWSM::rhoZ_q_SM() and EWSM::resumRhoZ() for detail.
KappaZ NORESUM / OMSI / INTERMEDIATE / OMSII / APPROXIMATEFORMULA This flag controls the formula used in computing the \(Zf\bar{f}\) couplings \(\kappa_Z^f\). The default flag is APPROXIMATEFORMULA. See EWSM::kappaZ_l_SM(), EWSM::kappaZ_q_SM() and EWSM::resumKappaZ() for detail.
MWinput TRUE / FALSE This auxiliary flag is used for setting the W mass as a SM input, instead of the electromagnetic constant parameter dAle5Mz. The default value is FALSE.
SMAux TRUE / FALSE This auxiliary flag is used for testing new options. The default value is FALSE.

These flags can be set via the method setFlag() or setFlagStr(), where the former is applicable for the boolean flags, while the latter is for the other flags. The method CheckFlags() is responsible for checking whether the flags are sane. The public member functions IsFlagWithoutNonUniversalVC(), IsFlagNoApproximateGammaZ() getFlagMw(), getFlagRhoZ() and getFlagKappaZ() are used to retrieve the values of each flag.

The first two flags CacheInStandardModel and CacheInEWSMcache for the cashing methods in EWSM and EWSMcache classes are relevant to the computations of the electroweak precision observables. Those caches are effective when the \(W\)-boson mass, the decay widths of the \(Z\) boson and the \(Zf\bar{f}\) effective couplings \(\kappa_Z^f\) are calculated without using their two-loop approximate formulae.

Notation

The on-mass-shell renormalization scheme [Sirlin:1980nh], [Marciano:1980pb], [Bardin:1980fe], [Bardin:1981sv] is adopted for UV divergences, and the weak mixing angle is defined in terms of the physical masses of the gauge bosons:

\[ s_W^2 \equiv \sin^2\theta_W = 1 - \frac{M_W^2}{M_Z^2}\,, \]

and \(c_W^2=1-s_W^2\).

The Fermi constant \(G_\mu\) in \(\mu\) decay is taken as an input quantity instead of the \(W\)-boson mass, since the latter has not been measured very precisely compared to the former. The relation between \(G_\mu\) and \(M_W\) is written as

\[ G_\mu = \frac{\pi\,\alpha}{\sqrt{2} s_W^2 M_W^2} (1+\Delta r)\,, \]

where \(\Delta r\) represents radiative corrections. From this relation, the \(W\)-boson mass is calculated as

\[ M_W^2 = \frac{M_Z^2}{2} \left( 1+\sqrt{1-\frac{4\pi\alpha}{\sqrt{2}G_\mu M_Z^2}\,(1+\Delta r)}\ \right). \]

The interaction between the \(Z\) boson and the neutral current can be written in terms of the effective \(Zf\bar{f}\) couplings \(g_{V}^f\) and \(g_{A}^f\), of \(g_{R}^f\) and \(g_{L}^f\), or of \(\rho_Z^f\) and \(\kappa_Z^f\):

\begin{eqnarray} \mathcal{L} &=& \frac{e}{2 s_W c_W}\, Z_\mu \sum_f \bar{f} \left( g_{V}^f\gamma_\mu - g_{A}^f \gamma_\mu\gamma_5 \right)\, f\,, \\ &=& \frac{e}{2s_W c_W}\, Z_\mu \sum_f \bar{f} \left[ g_{R}^f \gamma_\mu (1 + \gamma_5) + g_{L}^f \gamma_\mu (1 - \gamma_5) \right]\, f\,, \\ &=& \frac{e}{2 s_W c_W}\sqrt{\rho_Z^f}\, Z_\mu \sum_f \bar{f} \left[( I_3^f - 2Q_f\kappa_Z^f s_W^2)\gamma^\mu - I_3^f\gamma^\mu\gamma_5\right]\,f\,, \end{eqnarray}

where \(\rho_Z^f\) and \(\kappa_Z^f\) are related to \(g_{V}^f\) and \(g_{A}^f\) as the relations:

\begin{eqnarray} g_V^f &=& \sqrt{\rho_Z^f} I_3^f (1 - 4|Q_f|\kappa_Z^fs_W^2) = \sqrt{\rho_Z^f} (I_3^f - 2Q_f\kappa_Z^fs_W^2)\,, \qquad g_A^f &=& \sqrt{\rho_Z^f} I_3^f\,, \end{eqnarray}

and

\begin{eqnarray} \rho_Z^f &=& \left( \frac{g_A^f}{I_3^f} \right)^2, \qquad \kappa_Z^f &=& \frac{1}{4|Q_f|s_W^2} \left( 1 - \frac{g_V^{f}}{g_A^{f}}\right). \end{eqnarray}

Important member functions

The current class handles the following quantities:

  • \(M_W\)   (with Mw_SM()),
  • \(\Delta r\)   (with DeltaR_SM()),
  • \(c_W^2\) and \(s_W^2\)   (with cW2_SM() and sW2_SM()),
  • \(\Gamma_W\)   (with GammaW_SM()),
  • \(\rho_Z^f\)   (with rhoZ_l() and rhoZ_q()),
  • \(\kappa_Z^f\)   (with kappaZ_l() and kappaZ_q()),
  • \(g_V^f\)   (with gVl() and gVq()),
  • \(g_A^f\)   (with gAl() and gAq()),
  • \(\varepsilon_{1,2,3,b}\)   (with epsilon1_SM(), epsilon2_SM(), epsilon3_SM() and epsilonb_SM()).

Moreover, the functions Mzbar(), MwbarFromMw(), MwFromMwbar() and DeltaRbar_SM() can be used for the quantities in the complex-pole/fixed-width scheme.

Schemes

The formulae used for the \(W\)-boson mass \(M_W\) and the effective couplings \(\rho_Z^f\) and \(\kappa_Z^f\) are controlled with the model flags Mw, RhoZ and KappaZ of StandardModel. For each flag, the available schemes are as follows:

  • NORESUM:   No resummation is considered;
  • OMSI:   the so-called OMS-I scheme is adopted;
  • INTERMEDIATE:   an intermediate scheme between OMS-I and OMS-II is adopted;
  • OMSII:   the so-called OMS-II scheme is adopted;
  • APPROXIMATEFORMULA:   the approximate two-loop formula given in EWSMApproximateFormulae class is employed.

The scheme APPROXIMATEFORMULA provides the most accurate SM predictions for \(M_W\) and \(\kappa_Z^f\), while the approximate two-loop formula is not available for \(\rho_Z^f\).

See resumMw(), resumRhoZ() and resumKappaZ() for details on the other schemes.

Caches

This class contains caching methods for the following functions: DeltaAlphaLepton(), DeltaAlpha(), Mw_SM(), GammaW_SM(), rhoZ_l_SM(), rhoZ_q_SM(), kappaZ_l_SM() and kappaZ_q_SM(), to improve the performance of the Monte Carlo run. The caching methods are implemented with the function checkSMparams().

The use of the caching methods can be controlled with the model flag CacheInStandardModel of StandardModel.

Definition at line 509 of file StandardModel.h.

Public Types

enum  LEP2RCs { Weak = 0 , WeakBox , ISR , QEDFSR , QCDFSR , NUMofLEP2RCs }
 
enum  orders_EW { EW1 = 0 , EW1QCD1 , EW1QCD2 , EW2 , EW2QCD1 , EW3 , orders_EW_size }
 An enumerated type representing perturbative orders of radiative corrections to EW precision observables. More...
 
- Public Types inherited from QCD
enum  lepton { NEUTRINO_1 , ELECTRON , NEUTRINO_2 , MU , NEUTRINO_3 , TAU , NOLEPTON }
 An enum type for leptons. More...
 
enum  meson { P_0 , P_P , K_0 , K_P , D_0 , D_P , D_S , B_D , B_P , B_S , B_C , PHI , K_star , K_star_P , K_S , D_star_P , RHO , RHO_P , OMEGA , MESON_END }
 An enum type for mesons. More...
 
enum  quark { UP , DOWN , CHARM , STRANGE , TOP , BOTTOM }
 An enum type for quarks. More...
 

Public Member Functions

virtual const double A_f (const Particle f) const
 The left-right asymmetry in \(e^+e^-\to Z\to \ell \bar{\ell}\) at the \(Z\)-pole, \(\mathcal{A}_\ell\). More...
 
virtual const double AFB (const Particle f) const
 
gslpp::complex AH_f (const double tau) const
 Fermionic loop function entering in the calculation of the effective \(Hgg\) and \(H\gamma\gamma\) couplings. More...
 
gslpp::complex AH_W (const double tau) const
 W loop function entering in the calculation of the effective \(H\gamma\gamma\) coupling. More...
 
gslpp::complex AHZga_f (const double tau, const double lambda) const
 Fermionic loop function entering in the calculation of the effective \(HZ\gamma\) coupling. More...
 
gslpp::complex AHZga_W (const double tau, const double lambda) const
 W loop function entering in the calculation of the effective \(HZ\gamma\) coupling. More...
 
const double Ale (double mu, orders order, bool Nf_thr=true) const
 The running electromagnetic coupling \(\alpha_e(\mu)\) in the \(\overline{MS}\) scheme. More...
 
const double ale_OS (const double mu, orders order=FULLNLO) const
 The running electromagnetic coupling \(\alpha(\mu)\) in the on-shell scheme. More...
 
virtual const double alphaMz () const
 The electromagnetic coupling at the \(Z\)-mass scale, \(\alpha(M_Z^2)=\alpha/(1-\Delta\alpha(M_Z^2))\). More...
 
virtual const double alrmoller (const double q2, const double y) const
 The computation of the parity violating asymmetry in Moller scattering. More...
 
const double Als (const double mu, const int Nf_in, const orders order=FULLNLO) const
 Computes the running strong coupling \(\alpha_s(\mu)\) with \(N_f\) active flavours in the \(\overline{\mathrm{MS}}\) scheme. In the cases of LO, NLO and FULLNLO, the coupling is computed with AlsWithInit(). On the other hand, in the cases of NNLO and FULLNNLO, the coupling is computed with AlsWithLambda(). More...
 
const double Als (const double mu, const orders order, const bool Nf_thr, const bool qed_flag) const
 The running QCD coupling \(\alpha(\mu)\) in the \(\overline{MS}\) scheme including QED corrections. More...
 
const double Als (const double mu, const orders order=FULLNLO, const bool Nf_thr=true) const
 
const double Alstilde5 (const double mu) const
 The value of \(\frac{\alpha_s^{\mathrm{FULLNLO}}}{4\pi}\) at any scale \(\mu\) with the number of flavours \(n_f = 4\) and full EW corrections. More...
 
virtual const double amuon () const
 The computation of the anomalous magnetic moment of the muon \(a_\mu=(g_\mu-2)/2\). More...
 
const double Beta_e (int nm, unsigned int nf) const
 QED beta function coefficients - eq. (36) hep-ph/0512066. More...
 
const double Beta_s (int nm, unsigned int nf) const
 QCD beta function coefficients including QED corrections - eq. (36) hep-ph/0512066. More...
 
virtual const double BrHtobb () const
 The Br \((H\to b \bar{b})\) in the Standard Model. More...
 
virtual const double BrHtocc () const
 The Br \((H\to c \bar{c})\) in the Standard Model. More...
 
virtual const double BrHtogaga () const
 The Br \((H\to \gamma \gamma)\) in the Standard Model. More...
 
virtual const double BrHtogg () const
 The Br \(\(H\to gg)\) in the Standard Model. More...
 
virtual const double BrHtomumu () const
 The Br \((H\to \mu^+ \mu^-)\) in the Standard Model. More...
 
virtual const double BrHtoss () const
 The Br \((H\to s \bar{s})\) in the Standard Model. More...
 
virtual const double BrHtotautau () const
 The Br \((H\to \tau^+ \tau^-)\) in the Standard Model. More...
 
virtual const double BrHtoWWstar () const
 The Br \((H\to W W^*)\) in the Standard Model. More...
 
virtual const double BrHtoZga () const
 The Br \((H\to Z \gamma)\) in the Standard Model. More...
 
virtual const double BrHtoZZstar () const
 The Br \((H\to Z Z^*)\) in the Standard Model. More...
 
virtual const double BrW (const Particle fi, const Particle fj) const
 The branching ratio of the \(W\) boson decaying into a SM fermion pair, \(Br(W\to f_i f_j)\). More...
 
const double c02 () const
 The square of the cosine of the weak mixing angle \(c_0^2\) defined without weak radiative corrections. More...
 
virtual bool CheckFlags () const
 A method to check the sanity of the set of model flags. More...
 
virtual bool CheckParameters (const std::map< std::string, double > &DPars)
 A method to check if all the mandatory parameters for StandardModel have been provided in model initialization. More...
 
bool checkSMparamsForEWPO ()
 A method to check whether the parameters relevant to the EWPO are updated. More...
 
const double computeBrHto4f () const
 The Br \((H\to 4f)\) in the Standard Model. More...
 
const double computeBrHto4l2 () const
 The Br \((H\to 4l)\) \(l=e,\mu\) in the Standard Model. More...
 
const double computeBrHto4l3 () const
 The Br \((H\to 4l)\) \(l=e,\mu,\tau\) in the Standard Model. More...
 
const double computeBrHto4q () const
 The Br \((H\to 4q)\) in the Standard Model. More...
 
const double computeBrHto4v () const
 The Br \((H\to 4\nu)\) in the Standard Model. More...
 
const double computeBrHtobb () const
 The Br \((H\to bb)\) in the Standard Model. More...
 
const double computeBrHtocc () const
 The Br \((H\to cc)\) in the Standard Model. More...
 
const double computeBrHtoevmuv () const
 The Br \((H\to e \nu \mu \nu)\) in the Standard Model. More...
 
const double computeBrHtogaga () const
 The Br \((H\to\gamma\gamma)\) in the Standard Model. More...
 
const double computeBrHtogg () const
 The Br \((H\to gg)\) in the Standard Model. More...
 
const double computeBrHtollvv2 () const
 The Br \((H\to l^+ l^- \nu \nu)\) \(l=e,\mu\) in the Standard Model. More...
 
const double computeBrHtollvv3 () const
 The Br \((H\to l^+ l^- \nu \nu)\) \(l=e,\mu,\tau\) in the Standard Model. More...
 
const double computeBrHtomumu () const
 The Br \((H\to \mu\mu)\) in the Standard Model. More...
 
const double computeBrHtoss () const
 The Br \((H\to ss)\) in the Standard Model. More...
 
const double computeBrHtotautau () const
 The Br \((H\to \tau\tau)\) in the Standard Model. More...
 
const double computeBrHtoWW () const
 The Br \((H\to WW)\) in the Standard Model. More...
 
const double computeBrHtoZga () const
 The Br \((H\to Z\gamma)\) in the Standard Model. More...
 
const double computeBrHtoZZ () const
 The Br \((H\to ZZ)\) in the Standard Model. More...
 
void ComputeDeltaR_rem (const double Mw_i, double DeltaR_rem[orders_EW_size]) const
 A method to collect \(\Delta r_{\mathrm{rem}}\) computed via subclasses. More...
 
void ComputeDeltaRho (const double Mw_i, double DeltaRho[orders_EW_size]) const
 A method to collect \(\Delta\rho\) computed via subclasses. More...
 
const double computeGammaHgaga_tt () const
 The top loop contribution to \(H\to\gamma\gamma\) in the Standard Model. More...
 
const double computeGammaHgaga_tW () const
 The mixed \(t-W\) loop contribution to \(H\to\gamma\gamma\) in the Standard Model. More...
 
const double computeGammaHgaga_WW () const
 The \(W\) loop contribution to \(H\to\gamma\gamma\) in the Standard Model. More...
 
const double computeGammaHgg_bb () const
 The bottom loop contribution to \(H\to gg\) in the Standard Model. More...
 
const double computeGammaHgg_tb () const
 The top-bottom interference contribution to \(H\to gg\) in the Standard Model. More...
 
const double computeGammaHgg_tt () const
 The top loop contribution to \(H\to gg\) in the Standard Model. More...
 
const double computeGammaHTotal () const
 The Higgs total width in the Standard Model. More...
 
const double computeGammaHZga_tt () const
 The top loop contribution to \(H\to Z\gamma\) in the Standard Model. More...
 
const double computeGammaHZga_tW () const
 The mixed \(t-W\) loop contribution to \(H\to Z\gamma\) in the Standard Model. More...
 
const double computeGammaHZga_WW () const
 The \(W\) loop contribution to \(H\to Z\gamma\) in the Standard Model. Currently it returns the value of tab 41 in ref. [Heinemeyer:2013tqa]. More...
 
const double computeSigmabbH (const double sqrt_s) const
 The bbH production cross section in the Standard Model. More...
 
const double computeSigmaggH (const double sqrt_s) const
 The ggH cross section in the Standard Model. More...
 
const double computeSigmaggH_bb (const double sqrt_s) const
 The square of the bottom-quark contribution to the ggH cross section in the Standard Model. More...
 
const double computeSigmaggH_tb (const double sqrt_s) const
 The top-bottom interference contribution to the ggH cross section in the Standard Model. More...
 
const double computeSigmaggH_tt (const double sqrt_s) const
 The square of the top-quark contribution to the ggH cross section in the Standard Model. More...
 
const double computeSigmatHq (const double sqrt_s) const
 The tHq production cross section in the Standard Model. More...
 
const double computeSigmattH (const double sqrt_s) const
 The ttH production cross section in the Standard Model. More...
 
const double computeSigmaVBF (const double sqrt_s) const
 The VBF cross section in the Standard Model. More...
 
const double computeSigmaWF (const double sqrt_s) const
 The W fusion contribution \(\sigma_{WF}\) to higgs-production cross section in the Standard Model. More...
 
const double computeSigmaWH (const double sqrt_s) const
 The WH production cross section in the Standard Model. More...
 
const double computeSigmaZF (const double sqrt_s) const
 The Z fusion contribution \(\sigma_{ZF}\) to higgs-production cross section in the Standard Model. More...
 
const double computeSigmaZH (const double sqrt_s) const
 The ZH production cross section in the Standard Model. More...
 
const double computeSigmaZWF (const double sqrt_s) const
 The Z W interference fusion contribution \(\sigma_{ZWF}\) to higgs-production cross section in the Standard Model. More...
 
virtual const double cW2 () const
 
virtual const double cW2 (const double Mw_i) const
 The square of the cosine of the weak mixing angle in the on-shell scheme, denoted as \(c_W^2\). More...
 
virtual const double Dalpha5hMz () const
 The 5-quark contribution to the running of the em constant to the \(Z\) pole. \(\Delta\alpha_{had}^{(5)}(M_Z)\). More...
 
const double DeltaAlpha () const
 The total corrections to the electromagnetic coupling \(\alpha\) at the \(Z\)-mass scale, denoted as \(\Delta\alpha(M_Z^2)\). More...
 
const double DeltaAlphaL5q () const
 The sum of the leptonic and the five-flavour hadronic corrections to the electromagnetic coupling \(\alpha\) at the \(Z\)-mass scale, denoted as \(\Delta\alpha^{\ell+5q}(M_Z^2)\). More...
 
const double DeltaAlphaLepton (const double s) const
 Leptonic contribution to the electromagnetic coupling \(\alpha\), denoted as \(\Delta\alpha_{\mathrm{lept}}(s)\). More...
 
const double DeltaAlphaTop (const double s) const
 Top-quark contribution to the electromagnetic coupling \(\alpha\), denoted as \(\Delta\alpha_{\mathrm{top}}(s)\). More...
 
virtual const gslpp::complex deltaKappaZ_f (const Particle f) const
 Flavour non-universal vertex corrections to \(\kappa_Z^l\), denoted by \(\Delta\kappa_Z^l\). More...
 
virtual const double DeltaR () const
 The SM prediction for \(\Delta r\) derived from that for the \(W\) boson mass. More...
 
virtual const double DeltaRbar () const
 The SM prediction for \(\Delta \overline{r}\) derived from that for the \(W\)-boson mass. More...
 
virtual const gslpp::complex deltaRhoZ_f (const Particle f) const
 Flavour non-universal vertex corrections to \(\rho_Z^l\), denoted by \(\Delta\rho_Z^l\). More...
 
virtual const double eeffAFBbottom (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffAFBcharm (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffAFBe (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffAFBetsub (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffAFBmu (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffAFBstrange (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffAFBtau (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffRbottom (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffRcharm (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffRelectron (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffRelectrontsub (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffRmuon (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffRstrange (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffRtau (const double pol_e, const double pol_p, const double s) const
 
const double eeffsigma (const Particle f, const double pol_e, const double pol_p, const double s, const double cosmin, const double cosmax) const
 
virtual const double eeffsigmaBottom (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffsigmaCharm (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffsigmaE (const double pol_e, const double pol_p, const double s) const
 
const double eeffsigmaEbin (const double pol_e, const double pol_p, const double s, const double cosmin, const double cosmax) const
 
virtual const double eeffsigmaEtsub (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffsigmaHadron (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffsigmaMu (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffsigmaStrange (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffsigmaTau (const double pol_e, const double pol_p, const double s) const
 
virtual const double epsilon1 () const
 The SM contribution to the epsilon parameter \(\varepsilon_1\). More...
 
virtual const double epsilon2 () const
 The SM contribution to the epsilon parameter \(\varepsilon_2\). More...
 
virtual const double epsilon3 () const
 The SM contribution to the epsilon parameter \(\varepsilon_3\). More...
 
virtual const double epsilonb () const
 The SM contribution to the epsilon parameter \(\varepsilon_b\). More...
 
gslpp::complex f_triangle (const double tau) const
 Loop function entering in the calculation of the effective \(Hgg\) and \(H\gamma\gamma\) couplings. More...
 
gslpp::complex g_triangle (const double tau) const
 Loop function entering in the calculation of the effective \(HZ\gamma\) coupling. More...
 
virtual const gslpp::complex gA_f (const Particle f) const
 The effective leptonic neutral-current axial-vector coupling \(g_A^l\) in the SM. More...
 
virtual const double Gamma_had () const
 The hadronic decay width of the \(Z\) boson, \(\Gamma_{h}\). More...
 
virtual const double Gamma_inv () const
 The invisible partial decay width of the \(Z\) boson, \(\Gamma_{\mathrm{inv}}\). More...
 
virtual const double Gamma_muon () const
 The computation of the muon decay. More...
 
virtual const double Gamma_tau_l_nunu (const Particle l) const
 The computation of the leptonic tau decays. More...
 
virtual const double Gamma_Z () const
 The total decay width of the \(Z\) boson, \(\Gamma_Z\). More...
 
virtual const double GammaHtobb () const
 The \(\Gamma(H\to b \bar{b})\) in the Standard Model. More...
 
virtual const double GammaHtocc () const
 The \(\Gamma(H\to c \bar{c})\) in the Standard Model. More...
 
virtual const double GammaHtogaga () const
 The \(\Gamma(H\to \gamma \gamma)\) in the Standard Model. More...
 
virtual const double GammaHtogg () const
 The \(\Gamma(H\to gg)\) in the Standard Model. More...
 
virtual const double GammaHtomumu () const
 The \(\Gamma(H\to \mu^+ \mu^-)\) in the Standard Model. More...
 
virtual const double GammaHtoss () const
 The \(\Gamma(H\to s \bar{s})\) in the Standard Model. More...
 
virtual const double GammaHTot () const
 The total Higgs width \(\Gamma(H)\) in the Standard Model. More...
 
virtual const double GammaHtotautau () const
 The \(\Gamma(H\to \tau^+ \tau^-)\) in the Standard Model. More...
 
virtual const double GammaHtoWWstar () const
 The \(\Gamma(H\to W W^*)\) in the Standard Model. More...
 
virtual const double GammaHtoZga () const
 The \(\Gamma(H\to Z \gamma)\) in the Standard Model. More...
 
virtual const double GammaHtoZZstar () const
 The \(\Gamma(H\to Z Z^*)\) in the Standard Model. More...
 
virtual const double GammaW () const
 The total width of the \(W\) boson, \(\Gamma_W\). More...
 
virtual const double GammaW (const Particle fi, const Particle fj) const
 A partial decay width of the \(W\) boson decay into a SM fermion pair. More...
 
virtual const double GammaZ (const Particle f) const
 The \(Z\to \ell\bar{\ell}\) partial decay width, \(\Gamma_\ell\). More...
 
virtual const double gAnue () const
 The effective (muon) neutrino-electron axial-vector coupling: gAnue. More...
 
const double getAle () const
 A get method to retrieve the fine-structure constant \(\alpha\). More...
 
const double getAlsMz () const
 A get method to access the value of \(\alpha_s(M_Z)\). More...
 
virtual const double getCBd () const
 The ratio of the absolute value of the $B_d$ mixing amplitude over the Standard Model value. More...
 
virtual const double getCBs () const
 The ratio of the absolute value of the $B_s$ mixing amplitude over the Standard Model value. More...
 
virtual const double getCCC1 () const
 A virtual implementation for the RealWeakEFTCC class. More...
 
virtual const double getCCC2 () const
 A virtual implementation for the RealWeakEFTCC class. More...
 
virtual const double getCCC3 () const
 A virtual implementation for the RealWeakEFTCC class. More...
 
virtual const double getCCC4 () const
 A virtual implementation for the RealWeakEFTCC class. More...
 
virtual const double getCCC5 () const
 A virtual implementation for the RealWeakEFTCC class. More...
 
virtual const double getCDMK () const
 The ratio of the real part of the $K$ mixing amplitude over the Standard Model value. More...
 
virtual const double getCepsK () const
 The ratio of the imaginary part of the $K$ mixing amplitude over the Standard Model value. More...
 
const CKMgetCKM () const
 A get method to retrieve the member object of type CKM. More...
 
const double getDAle5Mz () const
 A get method to retrieve the five-flavour hadronic contribution to the electromagnetic coupling, \(\Delta\alpha_{\mathrm{had}}^{(5)}(M_Z^2)\). More...
 
const double getDelGammaZ () const
 A get method to retrieve the theoretical uncertainty in \(\Gamma_Z\), denoted as \(\delta\,\Gamma_Z\). More...
 
const double getDelMw () const
 A get method to retrieve the theoretical uncertainty in \(M_W\), denoted as \(\delta\,M_W\). More...
 
const double getDelR0b () const
 A get method to retrieve the theoretical uncertainty in \(R_b^0\), denoted as \(\delta\,R_b^0\). More...
 
const double getDelR0c () const
 A get method to retrieve the theoretical uncertainty in \(R_c^0\), denoted as \(\delta\,R_c^0\). More...
 
const double getDelR0l () const
 A get method to retrieve the theoretical uncertainty in \(R_l^0\), denoted as \(\delta\,R_l^0\). More...
 
const double getDelSigma0H () const
 A get method to retrieve the theoretical uncertainty in \(\sigma_{Hadron}^0\), denoted as \(\delta\,\sigma_{Hadron}^0\). More...
 
const double getDelSin2th_b () const
 A get method to retrieve the theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{b}\), denoted as \(\delta\sin^2\theta_{\rm eff}^{b}\). More...
 
const double getDelSin2th_l () const
 A get method to retrieve the theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{\rm lept}\), denoted as \(\delta\sin^2\theta_{\rm eff}^{\rm lept}\). More...
 
const double getDelSin2th_q () const
 A get method to retrieve the theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{q\not = b,t}\), denoted as \(\delta\sin^2\theta_{\rm eff}^{q\not = b,t}\). More...
 
const std::string getFlagKappaZ () const
 A method to retrieve the model flag KappaZ. More...
 
const std::string getFlagMw () const
 A method to retrieve the model flag Mw. More...
 
const std::string getFlagRhoZ () const
 A method to retrieve the model flag RhoZ. More...
 
const FlavourgetFlavour () const
 
const double getGF () const
 A get method to retrieve the Fermi constant \(G_\mu\). More...
 
const int getIterationNo () const
 
const ParticlegetLeptons (const QCD::lepton p) const
 A get method to retrieve the member object of a lepton. More...
 
virtual StandardModelMatchinggetMatching () const
 A get method to access the member reference of type StandardModelMatching. More...
 
virtual const double getMHl () const
 A get method to retrieve the Higgs mass \(m_h\). More...
 
virtual const double getmq (const QCD::quark q, const double mu) const
 The MSbar running quark mass computed at NLO. More...
 
const double getMuw () const
 A get method to retrieve the matching scale \(\mu_W\) around the weak scale. More...
 
const double getMw () const
 A get method to access the input value of the mass of the \(W\) boson \(M_W\). More...
 
EWSMApproximateFormulaegetMyApproximateFormulae () const
 A get method to retrieve the member pointer of type EWSMApproximateFormulae. More...
 
EWSMcachegetMyEWSMcache () const
 A get method to retrieve the member pointer of type EWSMcache. More...
 
LeptonFlavourgetMyLeptonFlavour () const
 
EWSMOneLoopEWgetMyOneLoopEW () const
 A get method to retrieve the member pointer of type EWSMOneLoopEW,. More...
 
EWSMThreeLoopEWgetMyThreeLoopEW () const
 
EWSMThreeLoopEW2QCDgetMyThreeLoopEW2QCD () const
 
EWSMThreeLoopQCDgetMyThreeLoopQCD () const
 
EWSMTwoFermionsLEP2getMyTwoFermionsLEP2 () const
 A get method to retrieve the member pointer of type EWSMTwoFermionsLEP2. More...
 
EWSMTwoLoopEWgetMyTwoLoopEW () const
 
EWSMTwoLoopQCDgetMyTwoLoopQCD () const
 
const double getMz () const
 A get method to access the mass of the \(Z\) boson \(M_Z\). More...
 
virtual const double getPhiBd () const
 Half the relative phase of the $B_d$ mixing amplitude w.r.t. the Standard Model one. More...
 
virtual const double getPhiBs () const
 Half the relative phase of the $B_s$ mixing amplitude w.r.t. the Standard Model one. More...
 
virtual const StandardModelgetTrueSM () const
 
const gslpp::matrix< gslpp::complex > getUPMNS () const
 A get method to retrieve the object of the PMNS matrix. More...
 
const gslpp::matrix< gslpp::complex > getVCKM () const
 A get method to retrieve the CKM matrix. More...
 
const gslpp::matrix< gslpp::complex > & getYd () const
 A get method to retrieve the Yukawa matrix of the down-type quarks, \(Y_d\). More...
 
const gslpp::matrix< gslpp::complex > & getYe () const
 A get method to retrieve the Yukawa matrix of the charged leptons, \(Y_e\). More...
 
const gslpp::matrix< gslpp::complex > & getYn () const
 A get method to retrieve the Yukawa matrix of the neutrinos, \(Y_\nu\). More...
 
const gslpp::matrix< gslpp::complex > & getYu () const
 A get method to retrieve the Yukawa matrix of the up-type quarks, \(Y_u\). More...
 
virtual const double gLnuN2 () const
 The effective neutrino nucleon LH coupling: gLnuN2. More...
 
virtual const double gRnuN2 () const
 The effective neutrino nucleon RH coupling: gRnuN2. More...
 
virtual const gslpp::complex gV_f (const Particle f) const
 The effective leptonic neutral-current vector coupling \(g_V^l\) in the SM. More...
 
virtual const double gVnue () const
 The effective (muon) neutrino-electron vector coupling: gVnue. More...
 
gslpp::complex I_triangle_1 (const double tau, const double lambda) const
 Loop function entering in the calculation of the effective \(HZ\gamma\) coupling. More...
 
gslpp::complex I_triangle_2 (const double tau, const double lambda) const
 Loop function entering in the calculation of the effective \(HZ\gamma\) coupling. More...
 
virtual bool Init (const std::map< std::string, double > &DPars)
 A method to initialize the model parameters. More...
 
virtual bool InitializeModel ()
 A method to initialize the model. More...
 
const double intMLL2eeeeus2 (const double s, const double t0, const double t1) const
 
const double intMLR2eeeets2 (const double s, const double t0, const double t1) const
 
const double intMLRtilde2eeeest2 (const double s, const double t0, const double t1) const
 
const double intMRR2eeeeus2 (const double s, const double t0, const double t1) const
 
const bool IsFlagNoApproximateGammaZ () const
 A method to retrieve the model flag NoApproximateGammaZ. More...
 
const bool IsFlagWithoutNonUniversalVC () const
 A method to retrieve the model flag WithoutNonUniversalVC. More...
 
virtual const gslpp::complex kappaZ_f (const Particle f) const
 The effective leptonic neutral-current coupling \(\kappa_Z^l\) in the SM. More...
 
virtual const double LEP2AFBbottom (const double s) const
 
virtual const double LEP2AFBcharm (const double s) const
 
virtual const double LEP2AFBe (const double s) const
 
virtual const double LEP2AFBmu (const double s) const
 
virtual const double LEP2AFBtau (const double s) const
 
virtual const double LEP2dsigmadcosBinE (const double s, const double cos, const double cosmin, const double cosmax) const
 
virtual const double LEP2dsigmadcosBinMu (const double s, const double cos, const double cosmin, const double cosmax) const
 
virtual const double LEP2dsigmadcosBinTau (const double s, const double cos, const double cosmin, const double cosmax) const
 
virtual const double LEP2dsigmadcosE (const double s, const double cos) const
 
virtual const double LEP2dsigmadcosMu (const double s, const double cos) const
 
virtual const double LEP2dsigmadcosTau (const double s, const double cos) const
 
virtual const double LEP2Rbottom (const double s) const
 
virtual const double LEP2Rcharm (const double s) const
 
virtual const double LEP2sigmaBottom (const double s) const
 
virtual const double LEP2sigmaCharm (const double s) const
 
virtual const double LEP2sigmaE (const double s) const
 
virtual const double LEP2sigmaHadron (const double s) const
 
virtual const double LEP2sigmaMu (const double s) const
 
virtual const double LEP2sigmaTau (const double s) const
 
const double MLL2eeff (const Particle f, const double s, const double t) const
 
const double MLR2eeff (const Particle f, const double s) const
 
const double MRL2eeff (const Particle f, const double s) const
 
const double MRR2eeff (const Particle f, const double s, const double t) const
 
virtual const double Mw () const
 The SM prediction for the \(W\)-boson mass in the on-shell scheme, \(M_{W,\mathrm{SM}}\). More...
 
const double Mw_tree () const
 The tree-level mass of the \(W\) boson, \(M_W^{\mathrm{tree}}\). More...
 
const double MwbarFromMw (const double Mw) const
 A method to convert the \(W\)-boson mass in the experimental/running-width scheme to that in the complex-pole/fixed-width scheme. More...
 
const double MwFromMwbar (const double Mwbar) const
 A method to convert the \(W\)-boson mass in the complex-pole/fixed-width scheme to that in the experimental/running-width scheme. More...
 
double Mzbar () const
 The \(Z\)-boson mass \(\overline{M}_Z\) in the complex-pole/fixed-width scheme. More...
 
virtual const double N_nu () const
 The number of neutrinos obtained indirectly from the measurements at the Z pole, \(N_{\nu}\). More...
 
virtual bool PostUpdate ()
 The post-update method for StandardModel. More...
 
virtual bool PreUpdate ()
 The pre-update method for StandardModel. More...
 
virtual const double Qwemoller (const double q2, const double y) const
 The computation of the electron's weak charge. More...
 
virtual const double Qwn () const
 The computation of the neutron weak charge: Qwn. More...
 
virtual const double Qwp () const
 The computation of the proton weak charge: Qwp. More...
 
virtual const double R0_f (const Particle f) const
 The ratio \(R_\ell^0=\Gamma(Z\to {\rm hadrons})/\Gamma(Z\to \ell^+ \ell^-)\). More...
 
virtual const double R_inv () const
 The ratio of the invisible and leptonic (electron) decay widths of the \(Z\) boson, \(R_{inv}\). More...
 
virtual const double rho_GammaW (const Particle fi, const Particle fj) const
 EW radiative corrections to the width of \(W \to f_i \bar{f}_j\), denoted as \(\rho^W_{ij}\). More...
 
virtual const gslpp::complex rhoZ_f (const Particle f) const
 The effective leptonic neutral-current coupling \(\rho_Z^l\) in the SM. More...
 
virtual const double Ruc () const
 
virtual const double RWc () const
 The ratio \(R_{W,c)=\Gamma(W\to c + X)/\Gamma(W\to had)\). More...
 
virtual const double RWlilj (const Particle li, const Particle lj) const
 The lepton universality ratio \(R_{W,l_i/l_j)=\Gamma(W\to l_i \nu_i)/\Gamma(W\to l_j \nu_j)\). More...
 
virtual const double RZlilj (const Particle li, const Particle lj) const
 The lepton universality ratio \(R_{Z,l_i/l_j)=\Gamma(Z\to l_i^+ l_i^-)/\Gamma(Z\to l_j^+ l_j^-)\). More...
 
const double s02 () const
 The square of the sine of the weak mixing angle \(s_0^2\) defined without weak radiative corrections. More...
 
void setCKM (const CKM &CKMMatrix)
 A set method to change the CKM matrix. More...
 
virtual bool setFlag (const std::string name, const bool value)
 A method to set a flag of StandardModel. More...
 
void setFlagCacheInStandardModel (bool FlagCacheInStandardModel)
 A set method to change the model flag CacheInStandardModel of StandardModel. More...
 
void setFlagNoApproximateGammaZ (bool FlagNoApproximateGammaZ)
 
bool setFlagSigmaForAFB (const bool flagSigmaForAFB_i)
 
bool setFlagSigmaForR (const bool flagSigmaForR_i)
 
virtual bool setFlagStr (const std::string name, const std::string value)
 A method to set a flag of StandardModel. More...
 
void setRequireCKM (bool requireCKM)
 A set method to change the value of requireCKM. More...
 
void setYd (const gslpp::matrix< gslpp::complex > &Yd)
 A set method to set the Yukawa matrix of the down-type quarks, \(Y_d\). More...
 
void setYe (const gslpp::matrix< gslpp::complex > &Ye)
 A set method to set the Yukawa matrix of the charged leptons, \(Y_e\). More...
 
void setYu (const gslpp::matrix< gslpp::complex > &Yu)
 A set method to set the Yukawa matrix of the up-type quarks, \(Y_u\). More...
 
virtual const double sigma0_had () const
 The hadronic cross section for \(e^+e^- \to Z \to \mathrm{hadrons}\) at the \(Z\)-pole, \(\sigma_h^0\). More...
 
virtual const double SigmaeeHee (const double sqrt_s, const double Pe, const double Pp) const
 The \(\sigma(e^+ e^- \to e^+ e^- H)\) in the Standard Model. More...
 
virtual const double SigmaeeHvv (const double sqrt_s, const double Pe, const double Pp) const
 The \(\sigma(e^+ e^- \to \nu \bar{\nu} H)\) in the Standard Model. More...
 
virtual const double SigmaeeZH (const double sqrt_s, const double Pe, const double Pp) const
 The \(\sigma(e^+ e^- \to Z H)\) in the Standard Model. More...
 
virtual const double sin2thetaEff (const Particle f) const
 The effective weak mixing angle \(\sin^2\theta_{\rm eff}^{\,\ell}\) for \(Z\ell\bar{\ell}\) at the the \(Z\)-mass scale. More...
 
 StandardModel ()
 The default constructor. More...
 
const double sW2 () const
 
virtual const double sW2 (const double Mw_i) const
 The square of the sine of the weak mixing angle in the on-shell scheme, denoted as \(s_W^2\). More...
 
const double sW2_MSbar_Approx () const
 The (approximated formula for the) square of the sine of the weak mixing angle in the MSbar scheme, denoted as \(\hat{s}_{W}^2\). See: PDG 22, R.L. Workman et al. (Particle Data Group), Prog. Theor. Exp. Phys. 2022, 083C01 (2022) More...
 
const double sW2_ND () const
 The square of the sine of the weak mixing angle in the MSbar-ND scheme (w/o decoupling $\alpha\ln(m_t/M_Z)$ terms), denoted as \(\hat{s}_{ND}^2\). See: PDG 22, R.L. Workman et al. (Particle Data Group), Prog. Theor. Exp. Phys. 2022, 083C01 (2022) (eq. 10.13a/10.13b) More...
 
virtual const double TauLFU_gmuge () const
 The computation of the LFU ratio \(g_\mu/ g_e \). More...
 
virtual const double TauLFU_gtauge () const
 The computation of the LFU ratio \(g_\tau/ g_e \). More...
 
virtual const double TauLFU_gtaugmu () const
 The computation of the LFU ratio \(g_\tau/ g_\mu \). More...
 
virtual const double TauLFU_gtaugmuK () const
 The computation of the LFU ratio \(\left(g_\tau/ g_\mu\right)_K \). More...
 
virtual const double TauLFU_gtaugmuPi () const
 The computation of the LFU ratio \(\left(g_\tau/ g_\mu\right)_\pi \). More...
 
virtual const double ThetaLnuN () const
 The effective neutrino nucleon LH parameter: ThetaLnuN. More...
 
virtual const double ThetaRnuN () const
 The effective neutrino nucleon RH parameter: ThetaRnuN. More...
 
const double tovers2 (const double cosmin, const double cosmax) const
 
const double uovers2 (const double cosmin, const double cosmax) const
 
virtual bool Update (const std::map< std::string, double > &DPars)
 The update method for StandardModel. More...
 
const double v () const
 The Higgs vacuum expectation value. More...
 
virtual ~StandardModel ()
 The default destructor. More...
 
- Public Member Functions inherited from QCD
const double AboveTh (const double mu) const
 The active flavour threshold above the scale \(\mu\) as defined in QCD::Thresholds(). More...
 
void addParameters (std::vector< std::string > params_i)
 A method to add parameters that are specific to only one set of observables. More...
 
const double Als (const double mu, const int Nf_in, const orders order=FULLNLO) const
 Computes the running strong coupling \(\alpha_s(\mu)\) with \(N_f\) active flavours in the \(\overline{\mathrm{MS}}\) scheme. In the cases of LO, NLO and FULLNLO, the coupling is computed with AlsWithInit(). On the other hand, in the cases of NNLO and FULLNNLO, the coupling is computed with AlsWithLambda(). More...
 
const double Als (const double mu, const orders order=FULLNLO, const bool Nf_thr=true) const
 
const double Als4 (const double mu) const
 The value of \(\alpha_s^{\mathrm{FULLNLO}}\) at any scale \(\mu\) with the number of flavours \(n_f = 4\). More...
 
const double AlsByOrder (const double mu, const int Nf_in, const orders order=FULLNLO) const
 
const double AlsByOrder (const double mu, const orders order=FULLNLO, bool Nf_thr=true) const
 
const double AlsOLD (const double mu, const orders order=FULLNLO) const
 Computes the running strong coupling \(\alpha_s(\mu)\) in the \(\overline{\mathrm{MS}}\) scheme. In the cases of LO, NLO and FULLNNLO, the coupling is computed with AlsWithInit(). On the other hand, in the cases of NNLO and FULLNNLO, the coupling is computed with AlsWithLambda(). More...
 
const double AlsWithInit (const double mu, const double alsi, const double mu_i, const int nf, const orders order) const
 Computes the running strong coupling \(\alpha_s(\mu)\) from \(\alpha_s(\mu_i)\) in the \(\overline{\mathrm{MS}}\) scheme, where it is forbidden to across a flavour threshold in the RG running from \(\mu_i\) to \(\mu\). More...
 
const double AlsWithLambda (const double mu, const orders order) const
 Computes the running strong coupling \(\alpha_s(\mu)\) in the \(\overline{\mathrm{MS}}\) scheme with the use of \(\Lambda_{\rm QCD}\). More...
 
const double BelowTh (const double mu) const
 The active flavour threshold below the scale \(\mu\) as defined in QCD::Thresholds(). More...
 
const double Beta0 (const double nf) const
 The \(\beta_0(n_f)\) coefficient for a certain number of flavours \(n_f\). More...
 
const double Beta1 (const double nf) const
 The \(\beta_1(n_f)\) coefficient for a certain number of flavours \(n_f\). More...
 
const double Beta2 (const double nf) const
 The \(\beta_2(n_f)\) coefficient for a certain number of flavours \(n_f\). More...
 
const double Beta3 (const double nf) const
 The \(\beta_3(n_f)\) coefficient for a certain number of flavours \(n_f\). More...
 
void CacheShift (double cache[][5], int n) const
 A member used to manage the caching for this class. More...
 
void CacheShift (int cache[][5], int n) const
 
const orders FullOrder (orders order) const
 Return the FULLORDER enum corresponding to order. More...
 
const double Gamma0 (const double nf) const
 The \(\gamma_0\) coefficient used to compute the running of a mass. More...
 
const double Gamma1 (const double nf) const
 The \(\gamma_1\) coefficient used to compute the running of a mass. More...
 
const double Gamma2 (const double nf) const
 The \(\gamma_2\) coefficient used to compute the running of a mass. More...
 
const double getAlsM () const
 A get method to access the value of \(\alpha_s(M_{\alpha_s})\). More...
 
const BParametergetBBd () const
 For getting the bag parameters corresponding to the operator basis \(O_1 -O_5\) in \(\Delta b = 2\) process in the \(B_d\) meson system. More...
 
const BParametergetBBd_subleading () const
 For getting the subleading bag parameters \(R_2 - R_3\) in \(\Delta b = 2\) process in the \(B_d\) meson system. More...
 
const BParametergetBBs () const
 For getting the bag parameters corresponding to the operator basis \(O_1 -O_5\) in \(\Delta b = 2\) process in the \(B_s\) meson system. More...
 
const BParametergetBBs_subleading () const
 For getting the subleading bag parameters \(R_2 - R_3\) in \(\Delta b = 2\) process in the \(B_s\) meson system. More...
 
const BParametergetBD () const
 For getting the bag parameters corresponding to the operator basis \(O_1 -O_5\) in \(\Delta c = 2\) process in the \(D^0\) meson system. More...
 
const BParametergetBK () const
 For getting the bag parameters corresponding to the operator basis \(O_1 -O_5\) in \(\Delta s = 2\) process in the \(K^0\) meson system. More...
 
const BParametergetBKd1 () const
 
const BParametergetBKd3 () const
 
const double getCF () const
 A get method to access the Casimir factor of QCD. More...
 
const double getMAls () const
 A get method to access the mass scale \(M_{\alpha_s}\) at which the strong coupling constant measurement is provided. More...
 
const MesongetMesons (const QCD::meson m) const
 A get method to access a meson as an object of the type Meson. More...
 
const double getMtpole () const
 A get method to access the pole mass of the top quark. More...
 
const double getMub () const
 A get method to access the threshold between five- and four-flavour theory in GeV. More...
 
const double getMuc () const
 A get method to access the threshold between four- and three-flavour theory in GeV. More...
 
const double getMut () const
 A get method to access the threshold between six- and five-flavour theory in GeV. More...
 
const double getNc () const
 A get method to access the number of colours \(N_c\). More...
 
const double getOptionalParameter (std::string name) const
 A method to get parameters that are specific to only one set of observables. More...
 
const ParticlegetQuarks (const QCD::quark q) const
 A get method to access a quark as an object of the type Particle. More...
 
std::vector< std::string > getUnknownParameters ()
 A method to get the vector of the parameters that have been specified in the configuration file but not being used. More...
 
void initializeBParameter (std::string name_i) const
 A method to initialize B Parameter and the corresponding meson. More...
 
void initializeMeson (QCD::meson meson_i) const
 A method to initialize a meson. More...
 
bool isQCDsuccess () const
 A getter for the QCDsuccess flag. More...
 
const double logLambda (const double nf, orders order) const
 Computes \(\ln\Lambda_\mathrm{QCD}\) with nf flavours in GeV. More...
 
const double Mbar2Mp (const double mbar, const quark q, const orders order=FULLNNLO) const
 Converts the \(\overline{\mathrm{MS}}\) mass \(m(m)\) to the pole mass. More...
 
const double Mofmu2Mbar (const double m, const double mu, const quark q) const
 Converts a quark running mass at an arbitrary scale to the corresponding \(\overline{\mathrm{MS}}\) mass \(m(m)\). More...
 
const double Mp2Mbar (const double mp, const quark q, orders order=FULLNNLO) const
 Converts a quark pole mass to the corresponding \(\overline{\mathrm{MS}}\) mass \(m(m)\). More...
 
const double Mrun (const double mu, const double m, const quark q, const orders order=FULLNNLO) const
 Computes a running quark mass \(m(\mu)\) from \(m(m)\). More...
 
const double Mrun (const double mu_f, const double mu_i, const double m, const quark q, const orders order=FULLNNLO) const
 Runs a quark mass from \(\mu_i\) to \(\mu_f\). More...
 
const double Mrun4 (const double mu_f, const double mu_i, const double m) const
 The running of a mass with the number of flavours \(n_f = 4\). More...
 
const double MS2DRqmass (const double MSbar) const
 Converts a quark mass from the \(\overline{\mathrm{MS}}\) scheme to the \(\overline{\mathrm{DR}}\) scheme. More...
 
const double MS2DRqmass (const double MSscale, const double MSbar) const
 Converts a quark mass from the \(\overline{\mathrm{MS}}\) scheme to the \(\overline{\mathrm{DR}}\) scheme. More...
 
const double Nf (const double mu) const
 The number of active flavour at scale \(\mu\). More...
 
const double NfThresholdCorrections (double mu, double M, double als, int nf, orders order) const
 Threshold corrections in matching \(\alpha_s(n_f+1)\) with \(\alpha_s(n_f)\) from eq. (34) of hep-ph/0512060. More...
 
const std::string orderToString (const orders order) const
 Converts an object of the enum type "orders" to the corresponding string. More...
 
 QCD ()
 Constructor. More...
 
void setComputemt (bool computemt)
 A set method to change the value of computemt. More...
 
void setMtpole (double mtpole_in)
 A method to set the pole mass of the top quark. More...
 
void setNc (double Nc)
 A set method to change the number of colours \(N_c\). More...
 
void setOptionalParameter (std::string name, double value)
 A method to set the parameter value for the parameters that are specific to only one set of observables. More...
 
void setQuarkMass (const quark q, const double mass)
 A set method to change the mass of a quark. More...
 
const double Thresholds (const int i) const
 For accessing the active flavour threshold scales. More...
 
- Public Member Functions inherited from Model
void addMissingModelParameter (const std::string &missingParameterName)
 
std::vector< std::string > getmissingModelParameters ()
 
unsigned int getMissingModelParametersCount ()
 
std::string getModelName () const
 A method to fetch the name of the model. More...
 
const double & getModelParam (std::string name) const
 
bool isModelFWC_DF2 () const
 
bool isModelGeneralTHDM () const
 
bool isModelGeorgiMachacek () const
 
bool IsModelInitialized () const
 A method to check if the model is initialized. More...
 
bool isModelLinearized () const
 
bool isModelNPquadratic () const
 
bool isModelParam (std::string name) const
 
bool isModelSUSY () const
 
bool isModelTHDM () const
 
bool isModelTHDMW () const
 
bool IsUpdateError () const
 A method to check if there was any error in the model update process. More...
 
 Model ()
 The default constructor. More...
 
void raiseMissingModelParameterCount ()
 
void setModelFWC_DF2 ()
 
void setModelGeneralTHDM ()
 
void setModelGeorgiMachacek ()
 
void setModelInitialized (bool ModelInitialized)
 A set method to fix the failure or success of the initialization of the model. More...
 
void setModelLinearized (bool linearized=true)
 
void setModelName (const std::string name)
 A method to set the name of the model. More...
 
void setModelNPquadratic (bool NPquadratic=true)
 
void setModelSUSY ()
 
void setModelTHDM ()
 
void setModelTHDMW ()
 
void setSliced (bool Sliced)
 
void setUpdateError (bool UpdateError)
 A set method to fix the update status as success or failure. More...
 
virtual ~Model ()
 The default destructor. More...
 

Static Public Attributes

static const double GeVminus2_to_nb = 389379.338
 
static const double Mw_error = 0.00001
 The target accuracy of the iterative calculation of the \(W\)-boson mass in units of GeV. More...
 
static const int NSMvars = 26
 The number of the model parameters in StandardModel. More...
 
static const int NumSMParamsForEWPO = 33
 The number of the SM parameters that are relevant to the EW precision observables. More...
 
static std::string SMvars [NSMvars]
 A string array containing the labels of the model parameters in StandardModel. More...
 
- Static Public Attributes inherited from QCD
static const int NQCDvars = 11
 The number of model parameters in QCD. More...
 
static std::string QCDvars [NQCDvars]
 An array containing the labels under which all QCD parameters are stored in a vector of ModelParameter via InputParser::ReadParameters(). More...
 

Protected Member Functions

const double AFB_NoISR_l (const QCD::lepton l_flavor, const double s) const
 
const double AFB_NoISR_q (const QCD::quark q_flavor, const double s) const
 
bool checkEWPOscheme (const std::string scheme) const
 A method to check if a given scheme name in string form is valid. More...
 
virtual void computeCKM ()
 The method to compute the CKM matrix. More...
 
virtual void computeYukawas ()
 The method to compute the Yukawas matrix. More...
 
double Delta_EWQCD (const QCD::quark q) const
 The non-factorizable EW-QCD corrections to the partial widths for \(Z\to q\bar{q}\), denoted as \(\Delta_{\mathrm{EW/QCD}}\). More...
 
const double getIntegrand_AFBnumeratorWithISR_bottom133 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_bottom167 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_bottom172 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_bottom183 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_bottom189 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_bottom192 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_bottom196 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_bottom200 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_bottom202 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_bottom205 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_bottom207 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_charm133 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_charm167 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_charm172 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_charm183 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_charm189 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_charm192 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_charm196 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_charm200 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_charm202 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_charm205 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_charm207 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_mu130 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_mu136 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_mu161 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_mu172 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_mu183 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_mu189 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_mu192 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_mu196 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_mu200 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_mu202 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_mu205 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_mu207 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_tau130 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_tau136 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_tau161 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_tau172 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_tau183 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_tau189 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_tau192 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_tau196 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_tau200 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_tau202 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_tau205 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_tau207 (double x) const
 
const double getIntegrand_dsigmaBox_bottom130 (double x) const
 
const double getIntegrand_dsigmaBox_bottom133 (double x) const
 
const double getIntegrand_dsigmaBox_bottom136 (double x) const
 
const double getIntegrand_dsigmaBox_bottom161 (double x) const
 
const double getIntegrand_dsigmaBox_bottom167 (double x) const
 
const double getIntegrand_dsigmaBox_bottom172 (double x) const
 
const double getIntegrand_dsigmaBox_bottom183 (double x) const
 
const double getIntegrand_dsigmaBox_bottom189 (double x) const
 
const double getIntegrand_dsigmaBox_bottom192 (double x) const
 
const double getIntegrand_dsigmaBox_bottom196 (double x) const
 
const double getIntegrand_dsigmaBox_bottom200 (double x) const
 
const double getIntegrand_dsigmaBox_bottom202 (double x) const
 
const double getIntegrand_dsigmaBox_bottom205 (double x) const
 
const double getIntegrand_dsigmaBox_bottom207 (double x) const
 
const double getIntegrand_dsigmaBox_charm130 (double x) const
 
const double getIntegrand_dsigmaBox_charm133 (double x) const
 
const double getIntegrand_dsigmaBox_charm136 (double x) const
 
const double getIntegrand_dsigmaBox_charm161 (double x) const
 
const double getIntegrand_dsigmaBox_charm167 (double x) const
 
const double getIntegrand_dsigmaBox_charm172 (double x) const
 
const double getIntegrand_dsigmaBox_charm183 (double x) const
 
const double getIntegrand_dsigmaBox_charm189 (double x) const
 
const double getIntegrand_dsigmaBox_charm192 (double x) const
 
const double getIntegrand_dsigmaBox_charm196 (double x) const
 
const double getIntegrand_dsigmaBox_charm200 (double x) const
 
const double getIntegrand_dsigmaBox_charm202 (double x) const
 
const double getIntegrand_dsigmaBox_charm205 (double x) const
 
const double getIntegrand_dsigmaBox_charm207 (double x) const
 
const double getIntegrand_dsigmaBox_down130 (double x) const
 
const double getIntegrand_dsigmaBox_down133 (double x) const
 
const double getIntegrand_dsigmaBox_down136 (double x) const
 
const double getIntegrand_dsigmaBox_down161 (double x) const
 
const double getIntegrand_dsigmaBox_down167 (double x) const
 
const double getIntegrand_dsigmaBox_down172 (double x) const
 
const double getIntegrand_dsigmaBox_down183 (double x) const
 
const double getIntegrand_dsigmaBox_down189 (double x) const
 
const double getIntegrand_dsigmaBox_down192 (double x) const
 
const double getIntegrand_dsigmaBox_down196 (double x) const
 
const double getIntegrand_dsigmaBox_down200 (double x) const
 
const double getIntegrand_dsigmaBox_down202 (double x) const
 
const double getIntegrand_dsigmaBox_down205 (double x) const
 
const double getIntegrand_dsigmaBox_down207 (double x) const
 
const double getIntegrand_dsigmaBox_mu130 (double x) const
 
const double getIntegrand_dsigmaBox_mu133 (double x) const
 
const double getIntegrand_dsigmaBox_mu136 (double x) const
 
const double getIntegrand_dsigmaBox_mu161 (double x) const
 
const double getIntegrand_dsigmaBox_mu167 (double x) const
 
const double getIntegrand_dsigmaBox_mu172 (double x) const
 
const double getIntegrand_dsigmaBox_mu183 (double x) const
 
const double getIntegrand_dsigmaBox_mu189 (double x) const
 
const double getIntegrand_dsigmaBox_mu192 (double x) const
 
const double getIntegrand_dsigmaBox_mu196 (double x) const
 
const double getIntegrand_dsigmaBox_mu200 (double x) const
 
const double getIntegrand_dsigmaBox_mu202 (double x) const
 
const double getIntegrand_dsigmaBox_mu205 (double x) const
 
const double getIntegrand_dsigmaBox_mu207 (double x) const
 
const double getIntegrand_dsigmaBox_strange130 (double x) const
 
const double getIntegrand_dsigmaBox_strange133 (double x) const
 
const double getIntegrand_dsigmaBox_strange136 (double x) const
 
const double getIntegrand_dsigmaBox_strange161 (double x) const
 
const double getIntegrand_dsigmaBox_strange167 (double x) const
 
const double getIntegrand_dsigmaBox_strange172 (double x) const
 
const double getIntegrand_dsigmaBox_strange183 (double x) const
 
const double getIntegrand_dsigmaBox_strange189 (double x) const
 
const double getIntegrand_dsigmaBox_strange192 (double x) const
 
const double getIntegrand_dsigmaBox_strange196 (double x) const
 
const double getIntegrand_dsigmaBox_strange200 (double x) const
 
const double getIntegrand_dsigmaBox_strange202 (double x) const
 
const double getIntegrand_dsigmaBox_strange205 (double x) const
 
const double getIntegrand_dsigmaBox_strange207 (double x) const
 
const double getIntegrand_dsigmaBox_tau130 (double x) const
 
const double getIntegrand_dsigmaBox_tau133 (double x) const
 
const double getIntegrand_dsigmaBox_tau136 (double x) const
 
const double getIntegrand_dsigmaBox_tau161 (double x) const
 
const double getIntegrand_dsigmaBox_tau167 (double x) const
 
const double getIntegrand_dsigmaBox_tau172 (double x) const
 
const double getIntegrand_dsigmaBox_tau183 (double x) const
 
const double getIntegrand_dsigmaBox_tau189 (double x) const
 
const double getIntegrand_dsigmaBox_tau192 (double x) const
 
const double getIntegrand_dsigmaBox_tau196 (double x) const
 
const double getIntegrand_dsigmaBox_tau200 (double x) const
 
const double getIntegrand_dsigmaBox_tau202 (double x) const
 
const double getIntegrand_dsigmaBox_tau205 (double x) const
 
const double getIntegrand_dsigmaBox_tau207 (double x) const
 
const double getIntegrand_dsigmaBox_up130 (double x) const
 
const double getIntegrand_dsigmaBox_up133 (double x) const
 
const double getIntegrand_dsigmaBox_up136 (double x) const
 
const double getIntegrand_dsigmaBox_up161 (double x) const
 
const double getIntegrand_dsigmaBox_up167 (double x) const
 
const double getIntegrand_dsigmaBox_up172 (double x) const
 
const double getIntegrand_dsigmaBox_up183 (double x) const
 
const double getIntegrand_dsigmaBox_up189 (double x) const
 
const double getIntegrand_dsigmaBox_up192 (double x) const
 
const double getIntegrand_dsigmaBox_up196 (double x) const
 
const double getIntegrand_dsigmaBox_up200 (double x) const
 
const double getIntegrand_dsigmaBox_up202 (double x) const
 
const double getIntegrand_dsigmaBox_up205 (double x) const
 
const double getIntegrand_dsigmaBox_up207 (double x) const
 
const double getIntegrand_sigmaWithISR_bottom130 (double x) const
 
const double getIntegrand_sigmaWithISR_bottom133 (double x) const
 
const double getIntegrand_sigmaWithISR_bottom136 (double x) const
 
const double getIntegrand_sigmaWithISR_bottom161 (double x) const
 
const double getIntegrand_sigmaWithISR_bottom167 (double x) const
 
const double getIntegrand_sigmaWithISR_bottom172 (double x) const
 
const double getIntegrand_sigmaWithISR_bottom183 (double x) const
 
const double getIntegrand_sigmaWithISR_bottom189 (double x) const
 
const double getIntegrand_sigmaWithISR_bottom192 (double x) const
 
const double getIntegrand_sigmaWithISR_bottom196 (double x) const
 
const double getIntegrand_sigmaWithISR_bottom200 (double x) const
 
const double getIntegrand_sigmaWithISR_bottom202 (double x) const
 
const double getIntegrand_sigmaWithISR_bottom205 (double x) const
 
const double getIntegrand_sigmaWithISR_bottom207 (double x) const
 
const double getIntegrand_sigmaWithISR_charm130 (double x) const
 
const double getIntegrand_sigmaWithISR_charm133 (double x) const
 
const double getIntegrand_sigmaWithISR_charm136 (double x) const
 
const double getIntegrand_sigmaWithISR_charm161 (double x) const
 
const double getIntegrand_sigmaWithISR_charm167 (double x) const
 
const double getIntegrand_sigmaWithISR_charm172 (double x) const
 
const double getIntegrand_sigmaWithISR_charm183 (double x) const
 
const double getIntegrand_sigmaWithISR_charm189 (double x) const
 
const double getIntegrand_sigmaWithISR_charm192 (double x) const
 
const double getIntegrand_sigmaWithISR_charm196 (double x) const
 
const double getIntegrand_sigmaWithISR_charm200 (double x) const
 
const double getIntegrand_sigmaWithISR_charm202 (double x) const
 
const double getIntegrand_sigmaWithISR_charm205 (double x) const
 
const double getIntegrand_sigmaWithISR_charm207 (double x) const
 
const double getIntegrand_sigmaWithISR_down130 (double x) const
 
const double getIntegrand_sigmaWithISR_down133 (double x) const
 
const double getIntegrand_sigmaWithISR_down136 (double x) const
 
const double getIntegrand_sigmaWithISR_down161 (double x) const
 
const double getIntegrand_sigmaWithISR_down167 (double x) const
 
const double getIntegrand_sigmaWithISR_down172 (double x) const
 
const double getIntegrand_sigmaWithISR_down183 (double x) const
 
const double getIntegrand_sigmaWithISR_down189 (double x) const
 
const double getIntegrand_sigmaWithISR_down192 (double x) const
 
const double getIntegrand_sigmaWithISR_down196 (double x) const
 
const double getIntegrand_sigmaWithISR_down200 (double x) const
 
const double getIntegrand_sigmaWithISR_down202 (double x) const
 
const double getIntegrand_sigmaWithISR_down205 (double x) const
 
const double getIntegrand_sigmaWithISR_down207 (double x) const
 
const double getIntegrand_sigmaWithISR_mu130 (double x) const
 
const double getIntegrand_sigmaWithISR_mu136 (double x) const
 
const double getIntegrand_sigmaWithISR_mu161 (double x) const
 
const double getIntegrand_sigmaWithISR_mu172 (double x) const
 
const double getIntegrand_sigmaWithISR_mu183 (double x) const
 
const double getIntegrand_sigmaWithISR_mu189 (double x) const
 
const double getIntegrand_sigmaWithISR_mu192 (double x) const
 
const double getIntegrand_sigmaWithISR_mu196 (double x) const
 
const double getIntegrand_sigmaWithISR_mu200 (double x) const
 
const double getIntegrand_sigmaWithISR_mu202 (double x) const
 
const double getIntegrand_sigmaWithISR_mu205 (double x) const
 
const double getIntegrand_sigmaWithISR_mu207 (double x) const
 
const double getIntegrand_sigmaWithISR_strange130 (double x) const
 
const double getIntegrand_sigmaWithISR_strange133 (double x) const
 
const double getIntegrand_sigmaWithISR_strange136 (double x) const
 
const double getIntegrand_sigmaWithISR_strange161 (double x) const
 
const double getIntegrand_sigmaWithISR_strange167 (double x) const
 
const double getIntegrand_sigmaWithISR_strange172 (double x) const
 
const double getIntegrand_sigmaWithISR_strange183 (double x) const
 
const double getIntegrand_sigmaWithISR_strange189 (double x) const
 
const double getIntegrand_sigmaWithISR_strange192 (double x) const
 
const double getIntegrand_sigmaWithISR_strange196 (double x) const
 
const double getIntegrand_sigmaWithISR_strange200 (double x) const
 
const double getIntegrand_sigmaWithISR_strange202 (double x) const
 
const double getIntegrand_sigmaWithISR_strange205 (double x) const
 
const double getIntegrand_sigmaWithISR_strange207 (double x) const
 
const double getIntegrand_sigmaWithISR_tau130 (double x) const
 
const double getIntegrand_sigmaWithISR_tau136 (double x) const
 
const double getIntegrand_sigmaWithISR_tau161 (double x) const
 
const double getIntegrand_sigmaWithISR_tau172 (double x) const
 
const double getIntegrand_sigmaWithISR_tau183 (double x) const
 
const double getIntegrand_sigmaWithISR_tau189 (double x) const
 
const double getIntegrand_sigmaWithISR_tau192 (double x) const
 
const double getIntegrand_sigmaWithISR_tau196 (double x) const
 
const double getIntegrand_sigmaWithISR_tau200 (double x) const
 
const double getIntegrand_sigmaWithISR_tau202 (double x) const
 
const double getIntegrand_sigmaWithISR_tau205 (double x) const
 
const double getIntegrand_sigmaWithISR_tau207 (double x) const
 
const double getIntegrand_sigmaWithISR_up130 (double x) const
 
const double getIntegrand_sigmaWithISR_up133 (double x) const
 
const double getIntegrand_sigmaWithISR_up136 (double x) const
 
const double getIntegrand_sigmaWithISR_up161 (double x) const
 
const double getIntegrand_sigmaWithISR_up167 (double x) const
 
const double getIntegrand_sigmaWithISR_up172 (double x) const
 
const double getIntegrand_sigmaWithISR_up183 (double x) const
 
const double getIntegrand_sigmaWithISR_up189 (double x) const
 
const double getIntegrand_sigmaWithISR_up192 (double x) const
 
const double getIntegrand_sigmaWithISR_up196 (double x) const
 
const double getIntegrand_sigmaWithISR_up200 (double x) const
 
const double getIntegrand_sigmaWithISR_up202 (double x) const
 
const double getIntegrand_sigmaWithISR_up205 (double x) const
 
const double getIntegrand_sigmaWithISR_up207 (double x) const
 
const double Integrand_AFBnumeratorWithISR_l (double x, const QCD::lepton l_flavor, const double s) const
 
const double Integrand_AFBnumeratorWithISR_q (double x, const QCD::quark q_flavor, const double s) const
 
const double Integrand_dsigmaBox_l (double cosTheta, const QCD::lepton l_flavor, const double s) const
 
const double Integrand_dsigmaBox_q (double cosTheta, const QCD::quark q_flavor, const double s) const
 
const double Integrand_sigmaWithISR_l (double x, const QCD::lepton l_flavor, const double s) const
 
const double Integrand_sigmaWithISR_q (double x, const QCD::quark q_flavor, const double s) const
 
double m_q (const QCD::quark q, const double mu, const orders order=FULLNLO) const
 
double RAq (const QCD::quark q) const
 The radiator factor associated with the final-state QED and QCD corrections to the the axial-vector-current interactions, \(R_A^q(M_Z^2)\). More...
 
double resumKappaZ (const double DeltaRho[orders_EW_size], const double deltaKappa_rem[orders_EW_size], const double DeltaRbar_rem, const bool bool_Zbb) const
 A method to compute the real part of the effetvive coupling \(\kappa_Z^f\) from \(\Delta\rho\), \(\delta\rho_{\rm rem}^{f}\) and \(\Delta r_{\mathrm{rem}}\). More...
 
double resumMw (const double Mw_i, const double DeltaRho[orders_EW_size], const double DeltaR_rem[orders_EW_size]) const
 A method to compute the \(W\)-boson mass from \(\Delta\rho\) and \(\Delta r_{\mathrm{rem}}\). More...
 
double resumRhoZ (const double DeltaRho[orders_EW_size], const double deltaRho_rem[orders_EW_size], const double DeltaRbar_rem, const bool bool_Zbb) const
 A method to compute the real part of the effective coupling \(\rho_Z^f\) from \(\Delta\rho\), \(\delta\rho_{\rm rem}^{f}\) and \(\Delta r_{\mathrm{rem}}\). More...
 
double RVh () const
 The singlet vector corrections to the hadronic \(Z\)-boson width, denoted as \(R_V^h\). More...
 
double RVq (const QCD::quark q) const
 The radiator factor associated with the final-state QED and QCD corrections to the the vector-current interactions, \(R_V^q(M_Z^2)\). More...
 
double SchemeToDouble (const std::string scheme) const
 A method to convert a given scheme name in string form into a floating-point number with double precision. More...
 
virtual void setParameter (const std::string name, const double &value)
 A method to set the value of a parameter of StandardModel. More...
 
const double sigma_NoISR_l (const QCD::lepton l_flavor, const double s) const
 
const double sigma_NoISR_q (const QCD::quark q_flavor, const double s) const
 
double taub () const
 Top-mass corrections to the \(Zb\bar{b}\) vertex, denoted by \(\tau_b\). More...
 
- Protected Member Functions inherited from QCD
const double MassOfNf (int nf) const
 The Mbar mass of the heaviest quark in the theory with Nf active flavour. More...
 

Protected Attributes

double A
 The CKM parameter \(A\) in the Wolfenstein parameterization. More...
 
double ale
 The fine-structure constant \(\alpha\). More...
 
double alpha21
 
double alpha31
 
double AlsMz
 The strong coupling constant at the Z-boson mass, \(\alpha_s(M_Z)\). More...
 
bool bSigmaForAFB
 
bool bSigmaForR
 
double dAl5hMz
 The five-flavour hadronic contribution to the electromagnetic coupling, \(\Delta\alpha_{\mathrm{had}}^{(5)}(M_Z^2)\). (Non-input parameter) More...
 
double dAle5Mz
 The five-flavour hadronic contribution to the electromagnetic coupling, \(\Delta\alpha_{\mathrm{had}}^{(5)}(M_Z^2)\), used as input for FlagMWinput = FALSE. More...
 
double delGammaZ
 The theoretical uncertainty in \(\Gamma_Z\), denoted as \(\delta\,\Gamma_Z\), in GeV. More...
 
double delMw
 The theoretical uncertainty in \(M_W\), denoted as \(\delta\,M_W\), in GeV. More...
 
double delR0b
 The theoretical uncertainty in \(R_b^0\), denoted as \(\delta\,R_b^0\). More...
 
double delR0c
 The theoretical uncertainty in \(R_c^0\), denoted as \(\delta\,R_c^0\). More...
 
double delR0l
 The theoretical uncertainty in \(R_l^0\), denoted as \(\delta\,R_l^0\). More...
 
double delsigma0H
 The theoretical uncertainty in \(\sigma_{Hadron}^0\), denoted as \(\delta\,\sigma_{Hadron}^0\) in nb. More...
 
double delSin2th_b
 The theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{b}\), denoted as \(\delta\sin^2\theta_{\rm eff}^{b}\). More...
 
double delSin2th_l
 The theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{\rm lept}\), denoted as \(\delta\sin^2\theta_{\rm eff}^{\rm lept}\). More...
 
double delSin2th_q
 The theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{q\not = b,t}\), denoted as \(\delta\sin^2\theta_{\rm eff}^{q\not = b,t}\). More...
 
double delta
 
double etab
 The CKM parameter \(\bar{\eta}\) in the Wolfenstein parameterization. More...
 
bool flag_order [orders_EW_size]
 An array of internal flags controlling the inclusions of higher-order corrections. More...
 
bool FlagFixMuwMut
 A boolean for the model flag FixMuwMut. More...
 
bool flagLEP2 [NUMofLEP2RCs]
 
double gamma
 \(\gamma \) used as an input for FlagWolfenstein = FALSE More...
 
double GF
 The Fermi constant \(G_\mu\) in \({\rm GeV}^{-2}\). More...
 
double lambda
 The CKM parameter \(\lambda\) in the Wolfenstein parameterization. More...
 
Particle leptons [6]
 An array of Particle objects for the leptons. More...
 
double mHl
 The Higgs mass \(m_h\) in GeV. More...
 
double muw
 A matching scale \(\mu_W\) around the weak scale in GeV. More...
 
double Mw_inp
 The mass of the \(W\) boson in GeV used as input for FlagMWinput = TRUE. More...
 
CKM myCKM
 An object of type CKM. More...
 
PMNS myPMNS
 
double Mz
 The mass of the \(Z\) boson in GeV. More...
 
bool requireCKM
 An internal flag to control whether the CKM matrix has to be recomputed. More...
 
bool requireYe
 An internal flag to control whether the charged-lepton Yukawa matrix has to be recomputed. More...
 
bool requireYn
 An internal flag to control whether the neutrino Yukawa matrix has to be recomputed. More...
 
double rhob
 The CKM parameter \(\bar{\rho}\) in the Wolfenstein parameterization. More...
 
double s12
 
double s13
 
double s23
 
Flavour SMFlavour
 An object of type Flavour. More...
 
Matching< StandardModelMatching, StandardModelSMM
 An object of type Matching. More...
 
double Vcb
 \(\vert V_{cb} \vert \) used as an input for FlagWolfenstein = FALSE More...
 
double Vub
 \(\vert V_{ub} \vert \) used as an input for FlagWolfenstein = FALSE More...
 
double Vud
 \(\vert V_{ud} \vert \) used as an input for FlagWolfenstein = FALSE and FlagUseVud = TRUE More...
 
double Vus
 \(\vert V_{us} \vert \) used as an input for FlagWolfenstein = FALSE More...
 
gslpp::matrix< gslpp::complex > Yd
 The Yukawa matrix of the down-type quarks. More...
 
gslpp::matrix< gslpp::complex > Ye
 The Yukawa matrix of the charged leptons. More...
 
gslpp::matrix< gslpp::complex > Yn
 The Yukawa matrix of the neutrinos. More...
 
gslpp::matrix< gslpp::complex > Yu
 The Yukawa matrix of the up-type quarks. More...
 
- Protected Attributes inherited from QCD
double AlsM
 The strong coupling constant at the mass scale MAls, \(\alpha_s(M_{\alpha_s})\). More...
 
double CA
 
double CF
 
bool computemt
 Switch for computing the \(\overline{\mathrm{MS}}\) mass of the top quark. More...
 
double dAdA_NA
 
double dFdA_NA
 
double dFdF_NA
 
bool FlagMpole2MbarNumeric
 A flag to determine whether the pole mass to \(\over \mathrm{MS}\) mass conversion is done numerically. More...
 
bool FlagMtPole
 A flag to determine whether the pole mass of the top quark is used as input. More...
 
double MAls
 The mass scale in GeV at which the strong coupling measurement is provided. More...
 
double mtpole
 The pole mass of the top quark. More...
 
double mub
 The threshold between five- and four-flavour theory in GeV. More...
 
double muc
 The threshold between four- and three-flavour theory in GeV. More...
 
double mut
 The threshold between six- and five-flavour theory in GeV. More...
 
double NA
 
double Nc
 The number of colours. More...
 
bool QCDsuccess =true
 
Particle quarks [6]
 The vector of all SM quarks. More...
 
bool requireYd
 Switch for generating the Yukawa couplings to the down-type quarks. More...
 
bool requireYu
 Switch for generating the Yukawa couplings to the up-type quarks. More...
 
double TF
 
- Protected Attributes inherited from Model
bool isSliced = false
 A boolean set to true if the current istance is a slice of an extended object. More...
 
std::map< std::string, std::reference_wrapper< const double > > ModelParamMap
 
bool UpdateError = false
 A boolean set to false if update is successful. More...
 

Private Member Functions

const double AleWithInit (double mu, double alsi, double mu_i, orders order) const
 
const double AlsE (double mu, orders order, bool Nf_thr) const
 
const double AlsEByOrder (double mu, orders order, bool Nf_thr) const
 
const double AlsEWithInit (double mu, double alsi, double mu_i, const int nf_i, orders order) const
 

Private Attributes

double ale_cache [10][CacheSize]
 Cache for \(\alpha_e\). More...
 
double als_cache [11][CacheSize]
 Cache for \(\alpha_s\). More...
 
double average
 
double DeltaAlpha_cache
 A cache of the value of \(\Delta\alpha(M_Z^2)\). More...
 
double DeltaAlphaLepton_cache
 A cache of the value of \(\Delta\alpha_{\mathrm{lept}}(M_Z^2)\). More...
 
double error
 
gsl_function f_GSL
 
bool FlagCacheInStandardModel
 A flag for caching (true by default). More...
 
std::string FlagKappaZ
 A string for the model flag KappaZ. More...
 
std::string FlagMw
 A string for the model flag Mw. More...
 
bool FlagMWinput
 A boolean for the model flag MWinput.
More...
 
bool FlagNoApproximateGammaZ
 A boolean for the model flag NoApproximateGammaZ. More...
 
std::string FlagRhoZ
 A string for the model flag RhoZ. More...
 
bool FlagSMAux
 A boolean for the model flag SMAux. More...
 
bool FlagUseVud
 A boolean for the model flag UseVud. More...
 
bool FlagWithoutNonUniversalVC
 A boolean for the model flag WithoutNonUniversalVC. More...
 
bool FlagWolfenstein
 A boolean for the model flag Wolfenstein. More...
 
double GammaW_cache
 A cache of the value of \(\Gamma_W\). More...
 
int iterationNo
 
gslpp::complex kappaZ_f_cache [12]
 A cache of the value of \(\kappa_Z^l\). More...
 
double Mw_cache
 A cache of the value of \(M_W\). More...
 
EWSMApproximateFormulaemyApproximateFormulae
 A pointer to an object of type EWSMApproximateFormulae. More...
 
EWSMcachemyEWSMcache
 A pointer to an object of type EWSMcache. More...
 
LeptonFlavourmyLeptonFlavour
 A pointer to an object of the type LeptonFlavour. More...
 
EWSMOneLoopEWmyOneLoopEW
 A pointer to an object of type EWSMOneLoopEW. More...
 
EWSMThreeLoopEWmyThreeLoopEW
 A pointer to an object of type EWSMThreeLoopEW. More...
 
EWSMThreeLoopEW2QCDmyThreeLoopEW2QCD
 A pointer to an object of type EWSMThreeLoopEW2QCD. More...
 
EWSMThreeLoopQCDmyThreeLoopQCD
 A pointer to an object of type EWSMThreeLoopQCD. More...
 
EWSMTwoFermionsLEP2myTwoFermionsLEP2
 A pointer to an object of type EWSMTwoFermionsLEP2. More...
 
EWSMTwoLoopEWmyTwoLoopEW
 A pointer to an object of type EWSMTwoLoopEW. More...
 
EWSMTwoLoopQCDmyTwoLoopQCD
 A pointer to an object of type EWSMTwoLoopQCD. More...
 
orders realorder
 
gslpp::complex rhoZ_f_cache [12]
 A cache of the value of \(\rho_Z^l\). More...
 
double SMparamsForEWPO_cache [NumSMParamsForEWPO]
 
double SMresult_cache
 
bool useDeltaAlpha_cache
 
bool useDeltaAlphaLepton_cache
 
bool useGammaW_cache
 
bool useKappaZ_f_cache [12]
 
bool useMw_cache
 
bool useRhoZ_f_cache [12]
 
gsl_integration_workspace * w_GSL1
 

Static Private Attributes

static const int CacheSize = 5
 Defines the depth of the cache. More...
 

Member Enumeration Documentation

◆ LEP2RCs

Enumerator
Weak 
WeakBox 
ISR 
QEDFSR 
QCDFSR 
NUMofLEP2RCs 

Definition at line 514 of file StandardModel.h.

◆ orders_EW

An enumerated type representing perturbative orders of radiative corrections to EW precision observables.

Enumerator
EW1 

One-loop of \(\mathcal{O}(\alpha)\).

EW1QCD1 

Two-loop of \(\mathcal{O}(\alpha\alpha_s)\).

EW1QCD2 

Three-loop of \(\mathcal{O}(\alpha\alpha_s^2)\).

EW2 

Two-loop of \(\mathcal{O}(\alpha^2)\).

EW2QCD1 

Three-loop of \(\mathcal{O}(\alpha^2\alpha_s)\).

EW3 

Three-loop of \(\mathcal{O}(\alpha^3)\).

orders_EW_size 

The size of this enum.

Definition at line 527 of file StandardModel.h.

527 {
528 EW1 = 0,
529 EW1QCD1,
530 EW1QCD2,
531 EW2,
532 EW2QCD1,
533 EW3,
535 };
@ EW1
One-loop of .
@ EW2QCD1
Three-loop of .
@ EW2
Two-loop of .
@ orders_EW_size
The size of this enum.
@ EW3
Three-loop of .
@ EW1QCD1
Two-loop of .
@ EW1QCD2
Three-loop of .

Constructor & Destructor Documentation

◆ StandardModel()

StandardModel::StandardModel ( )

The default constructor.

Definition at line 41 of file StandardModel/src/StandardModel.cpp.

42: QCD(), Yu(3, 3, 0.), Yd(3, 3, 0.), Yn(3, 3, 0.),
43SMM(*this), SMFlavour(*this), Ye(3, 3, 0.)
44{
45 setModelName("StandardModel");
46 requireCKM = false;
47 requireYe = false;
48 requireYn = false;
49
52 FlagMw = "APPROXIMATEFORMULA";
53 FlagRhoZ = "NORESUM";
54 FlagKappaZ = "APPROXIMATEFORMULA";
55 FlagWolfenstein = true;
56 FlagUseVud = false;
57 FlagFixMuwMut = false;
58
59 FlagMWinput = false;
60
61 FlagSMAux = false;
62
63 /* Internal flags for EWPO (for debugging) */
64 flag_order[EW1] = true;
65 flag_order[EW1QCD1] = true;
66 flag_order[EW1QCD2] = true;
67 flag_order[EW2] = true;
68 flag_order[EW2QCD1] = true;
69 flag_order[EW3] = true;
70
71 //Flags for LEP2 observables
72 flagLEP2[Weak] = true;
73 flagLEP2[WeakBox] = true;
74 flagLEP2[ISR] = true;
75 flagLEP2[QEDFSR] = true;
76 flagLEP2[QCDFSR] = true;
77
78 bSigmaForAFB = false;
79 bSigmaForR = false;
80
81 // Caches for EWPO
82 FlagCacheInStandardModel = true; // use caches in the current class
84 useDeltaAlpha_cache = false;
85 useMw_cache = false;
86 useGammaW_cache = false;
88 DeltaAlpha_cache = 0.0;
89 Mw_cache = 0.0;
90 GammaW_cache = 0.0;
91 for (int i = 0; i < 12; ++i) {
92 useRhoZ_f_cache[i] = false;
93 useKappaZ_f_cache[i] = false;
94 rhoZ_f_cache[i] = gslpp::complex(0.0, 0.0, false);
95 kappaZ_f_cache[i] = gslpp::complex(0.0, 0.0, false);
96 }
97
98 myEWSMcache = NULL;
99 myOneLoopEW = NULL;
100 myTwoLoopQCD = NULL;
101 myThreeLoopQCD = NULL;
102 myTwoLoopEW = NULL;
103 myThreeLoopEW2QCD = NULL;
104 myThreeLoopEW = NULL;
106 /* BEGIN: REMOVE FROM THE PACKAGE */
107 myTwoFermionsLEP2 = NULL;
108 /* END: REMOVE FROM THE PACKAGE */
109
110 // Particle(std::string name, double mass, double mass_scale = 0., double width = 0., double charge = 0.,double isospin = 0.);
111 leptons[NEUTRINO_1] = Particle("NEUTRINO_1", 0., 0., 0., 0., .5);
112 leptons[NEUTRINO_2] = Particle("NEUTRINO_2", 0., 0., 0., 0., .5);
113 leptons[NEUTRINO_3] = Particle("NEUTRINO_3", 0., 0., 0., 0., .5);
114 leptons[ELECTRON] = Particle("ELECTRON", 0., 0., 0., -1., -.5);
115 leptons[MU] = Particle("MU", 0., 0., 0., -1., -.5);
116 leptons[TAU] = Particle("TAU", 0., 0., 0., -1., -.5);
117
118 ModelParamMap.insert(std::make_pair("Mz", std::cref(Mz)));
119 ModelParamMap.insert(std::make_pair("AlsMz", std::cref(AlsMz)));
120 ModelParamMap.insert(std::make_pair("GF", std::cref(GF)));
121 ModelParamMap.insert(std::make_pair("ale", std::cref(ale)));
122 ModelParamMap.insert(std::make_pair("dAle5Mz", std::cref(dAle5Mz)));
123// ModelParamMap.insert(std::make_pair("Mw_inp", std::cref(Mw_inp)));
124 ModelParamMap.insert(std::make_pair("mHl", std::cref(mHl)));
125 ModelParamMap.insert(std::make_pair("delMw", std::cref(delMw)));
126 ModelParamMap.insert(std::make_pair("delSin2th_l", std::cref(delSin2th_l)));
127 ModelParamMap.insert(std::make_pair("delSin2th_q", std::cref(delSin2th_q)));
128 ModelParamMap.insert(std::make_pair("delSin2th_b", std::cref(delSin2th_b)));
129 ModelParamMap.insert(std::make_pair("delGammaZ", std::cref(delGammaZ)));
130 ModelParamMap.insert(std::make_pair("delsigma0H", std::cref(delsigma0H)));
131 ModelParamMap.insert(std::make_pair("delR0l", std::cref(delR0l)));
132 ModelParamMap.insert(std::make_pair("delR0c", std::cref(delR0c)));
133 ModelParamMap.insert(std::make_pair("delR0b", std::cref(delR0b)));
134 ModelParamMap.insert(std::make_pair("mneutrino_1", std::cref(leptons[NEUTRINO_1].getMass())));
135 ModelParamMap.insert(std::make_pair("mneutrino_2", std::cref(leptons[NEUTRINO_2].getMass())));
136 ModelParamMap.insert(std::make_pair("mneutrino_3", std::cref(leptons[NEUTRINO_3].getMass())));
137 ModelParamMap.insert(std::make_pair("melectron", std::cref(leptons[ELECTRON].getMass())));
138 ModelParamMap.insert(std::make_pair("mmu", std::cref(leptons[MU].getMass())));
139 ModelParamMap.insert(std::make_pair("mtau", std::cref(leptons[TAU].getMass())));
140 ModelParamMap.insert(std::make_pair("lambda", std::cref(lambda)));
141 ModelParamMap.insert(std::make_pair("A", std::cref(A)));
142 ModelParamMap.insert(std::make_pair("rhob", std::cref(rhob)));
143 ModelParamMap.insert(std::make_pair("etab", std::cref(etab)));
144 ModelParamMap.insert(std::make_pair("muw", std::cref(muw)));
145
146 iterationNo = 0;
147 realorder = LO;
148
149 w_GSL1 = gsl_integration_workspace_alloc (200);
150}
@ LO
Definition: OrderScheme.h:34
std::map< std::string, std::reference_wrapper< const double > > ModelParamMap
Definition: Model.h:280
void setModelName(const std::string name)
A method to set the name of the model.
Definition: Model.h:50
A class for particles.
Definition: Particle.h:26
QCD()
Constructor.
Definition: QCD.cpp:29
@ NEUTRINO_2
Definition: QCD.h:313
@ NEUTRINO_1
Definition: QCD.h:311
@ MU
Definition: QCD.h:314
@ ELECTRON
Definition: QCD.h:312
@ NEUTRINO_3
Definition: QCD.h:315
@ TAU
Definition: QCD.h:316
double dAle5Mz
The five-flavour hadronic contribution to the electromagnetic coupling, , used as input for FlagMWinp...
EWSMThreeLoopEW * myThreeLoopEW
A pointer to an object of type EWSMThreeLoopEW.
double delSin2th_b
The theoretical uncertainty in , denoted as .
double A
The CKM parameter in the Wolfenstein parameterization.
bool requireCKM
An internal flag to control whether the CKM matrix has to be recomputed.
std::string FlagRhoZ
A string for the model flag RhoZ.
double Mz
The mass of the boson in GeV.
EWSMThreeLoopQCD * myThreeLoopQCD
A pointer to an object of type EWSMThreeLoopQCD.
double GammaW_cache
A cache of the value of .
double delMw
The theoretical uncertainty in , denoted as , in GeV.
bool flag_order[orders_EW_size]
An array of internal flags controlling the inclusions of higher-order corrections.
EWSMTwoLoopEW * myTwoLoopEW
A pointer to an object of type EWSMTwoLoopEW.
bool FlagFixMuwMut
A boolean for the model flag FixMuwMut.
bool useDeltaAlpha_cache
bool requireYn
An internal flag to control whether the neutrino Yukawa matrix has to be recomputed.
gsl_integration_workspace * w_GSL1
gslpp::matrix< gslpp::complex > Yn
The Yukawa matrix of the neutrinos.
EWSMTwoFermionsLEP2 * myTwoFermionsLEP2
A pointer to an object of type EWSMTwoFermionsLEP2.
Matching< StandardModelMatching, StandardModel > SMM
An object of type Matching.
gslpp::matrix< gslpp::complex > Yu
The Yukawa matrix of the up-type quarks.
std::string FlagMw
A string for the model flag Mw.
double delsigma0H
The theoretical uncertainty in , denoted as in nb.
double rhob
The CKM parameter in the Wolfenstein parameterization.
Particle leptons[6]
An array of Particle objects for the leptons.
double delSin2th_l
The theoretical uncertainty in , denoted as .
bool FlagMWinput
A boolean for the model flag MWinput.
Flavour SMFlavour
An object of type Flavour.
bool FlagWithoutNonUniversalVC
A boolean for the model flag WithoutNonUniversalVC.
bool FlagSMAux
A boolean for the model flag SMAux.
gslpp::matrix< gslpp::complex > Yd
The Yukawa matrix of the down-type quarks.
EWSMOneLoopEW * myOneLoopEW
A pointer to an object of type EWSMOneLoopEW.
double delR0c
The theoretical uncertainty in , denoted as .
std::string FlagKappaZ
A string for the model flag KappaZ.
double GF
The Fermi constant in .
EWSMApproximateFormulae * myApproximateFormulae
A pointer to an object of type EWSMApproximateFormulae.
double Mw_cache
A cache of the value of .
double DeltaAlphaLepton_cache
A cache of the value of .
double delSin2th_q
The theoretical uncertainty in , denoted as .
bool FlagUseVud
A boolean for the model flag UseVud.
bool FlagNoApproximateGammaZ
A boolean for the model flag NoApproximateGammaZ.
gslpp::complex kappaZ_f_cache[12]
A cache of the value of .
double lambda
The CKM parameter in the Wolfenstein parameterization.
bool useDeltaAlphaLepton_cache
double etab
The CKM parameter in the Wolfenstein parameterization.
EWSMcache * myEWSMcache
A pointer to an object of type EWSMcache.
gslpp::complex rhoZ_f_cache[12]
A cache of the value of .
double mHl
The Higgs mass in GeV.
double ale
The fine-structure constant .
bool flagLEP2[NUMofLEP2RCs]
double AlsMz
The strong coupling constant at the Z-boson mass, .
double delGammaZ
The theoretical uncertainty in , denoted as , in GeV.
gslpp::matrix< gslpp::complex > Ye
The Yukawa matrix of the charged leptons.
double muw
A matching scale around the weak scale in GeV.
bool useRhoZ_f_cache[12]
double delR0b
The theoretical uncertainty in , denoted as .
EWSMTwoLoopQCD * myTwoLoopQCD
A pointer to an object of type EWSMTwoLoopQCD.
bool FlagWolfenstein
A boolean for the model flag Wolfenstein.
bool requireYe
An internal flag to control whether the charged-lepton Yukawa matrix has to be recomputed.
EWSMThreeLoopEW2QCD * myThreeLoopEW2QCD
A pointer to an object of type EWSMThreeLoopEW2QCD.
bool useKappaZ_f_cache[12]
bool FlagCacheInStandardModel
A flag for caching (true by default).
double DeltaAlpha_cache
A cache of the value of .
double delR0l
The theoretical uncertainty in , denoted as .

◆ ~StandardModel()

StandardModel::~StandardModel ( )
virtual

The default destructor.

Definition at line 152 of file StandardModel/src/StandardModel.cpp.

153{
154 if (IsModelInitialized()) {
155 if (myEWSMcache != NULL) delete(myEWSMcache);
156 if (myOneLoopEW != NULL) delete(myOneLoopEW);
157 if (myTwoLoopQCD != NULL) delete(myTwoLoopQCD);
158 if (myThreeLoopQCD != NULL) delete(myThreeLoopQCD);
159 if (myTwoLoopEW != NULL) delete(myTwoLoopEW);
160 if (myThreeLoopEW2QCD != NULL) delete(myThreeLoopEW2QCD);
161 if (myThreeLoopEW != NULL) delete(myThreeLoopEW);
162 if (myApproximateFormulae != NULL) delete(myApproximateFormulae);
163 if (myLeptonFlavour != NULL) delete(myLeptonFlavour);
164 /* BEGIN: REMOVE FROM THE PACKAGE */
165 if (myTwoFermionsLEP2 != NULL) delete(myTwoFermionsLEP2);
166 /* END: REMOVE FROM THE PACKAGE */
167 }
168}
bool IsModelInitialized() const
A method to check if the model is initialized.
Definition: Model.h:136
LeptonFlavour * myLeptonFlavour
A pointer to an object of the type LeptonFlavour.

Member Function Documentation

◆ A_f()

const double StandardModel::A_f ( const Particle  f) const
virtual

The left-right asymmetry in \(e^+e^-\to Z\to \ell \bar{\ell}\) at the \(Z\)-pole, \(\mathcal{A}_\ell\).

The asymmetry \(\mathcal{A}_\ell\) is given by

\[ \mathcal{A}_\ell = \frac{2\, {\rm Re}\left(g_{V}^\ell/g_{A}^\ell\right)} {1+\left[{\rm Re}\left(g_{V}^\ell/g_{A}^\ell\right)\right]^2}\,, \]

where the ratio of the effective couplings \(g_{V}^\ell/g_{A}^\ell\) is computed via the two-loop approximate formula of \(\sin^2\theta_{\rm eff}^{\,\ell}\), EWSMApproximateFormulae::sin2thetaEff_l(), when checkNPZff_linearized() returns true and the model flag KappaZ of StandardModel is set to APPROXIMATEFORMULA.

Parameters
[in]fa lepton or quark
Returns
\(\mathcal{A}_\ell\)

Reimplemented in NPbase, NPSMEFTd6General, NPZbbbar, and NPEpsilons.

Definition at line 1338 of file StandardModel/src/StandardModel.cpp.

1339{
1340 double Re_kappa = kappaZ_f(f).real();
1341 double Re_gV_over_gA = 1.0 - 4.0 * fabs(f.getCharge()) * Re_kappa * sW2();
1342 return ( 2.0 * Re_gV_over_gA / (1.0 + pow(Re_gV_over_gA, 2.0)));
1343}
double getCharge() const
A get method to access the particle charge.
Definition: Particle.h:97
virtual const gslpp::complex kappaZ_f(const Particle f) const
The effective leptonic neutral-current coupling in the SM.

◆ AFB()

const double StandardModel::AFB ( const Particle  f) const
virtual
Parameters
[in]fa lepton or quark
Returns

Reimplemented in NPbase, NPSMEFTd6General, NPZbbbar, and NPEpsilons.

Definition at line 1345 of file StandardModel/src/StandardModel.cpp.

1346{
1347 return (3.0 / 4.0 * A_f(leptons[ELECTRON]) * A_f(f));
1348}
virtual const double A_f(const Particle f) const
The left-right asymmetry in at the -pole, .

◆ AFB_NoISR_l()

const double StandardModel::AFB_NoISR_l ( const QCD::lepton  l_flavor,
const double  s 
) const
protected

Definition at line 8027 of file StandardModel/src/StandardModel.cpp.

8028{
8029 double ml = getLeptons(l_flavor).getMass();
8030 double AFB = myTwoFermionsLEP2->AFB_l(l_flavor, ml, s, Mw(), Gamma_Z(), flagLEP2[Weak]);
8031
8032 return AFB;
8033}
double AFB_l(const QCD::lepton l, const double mf, const double s, const double Mw, const double GammaZ, const bool bWeak) const
const double & getMass() const
A get method to access the particle mass.
Definition: Particle.h:61
const Particle & getLeptons(const QCD::lepton p) const
A get method to retrieve the member object of a lepton.
virtual const double AFB(const Particle f) const
virtual const double Gamma_Z() const
The total decay width of the boson, .
virtual const double Mw() const
The SM prediction for the -boson mass in the on-shell scheme, .
Test Observable.

◆ AFB_NoISR_q()

const double StandardModel::AFB_NoISR_q ( const QCD::quark  q_flavor,
const double  s 
) const
protected

Definition at line 8035 of file StandardModel/src/StandardModel.cpp.

8036{
8037 double mq = m_q(q_flavor, sqrt(s));
8038 double AFB = myTwoFermionsLEP2->AFB_q(q_flavor, mq, s, Mw(), Gamma_Z(), flagLEP2[Weak]);
8039
8040 if (flagLEP2[QCDFSR])
8041 AFB *= myTwoFermionsLEP2->QCD_FSR_forAFB(q_flavor, mq, s);
8042
8043 return AFB;
8044}
double AFB_q(const QCD::quark q, const double mf, const double s, const double Mw, const double GammaZ, const bool bWeak) const
double QCD_FSR_forAFB(const QCD::quark q, const double mf, const double s) const
double m_q(const QCD::quark q, const double mu, const orders order=FULLNLO) const

◆ AH_f()

gslpp::complex StandardModel::AH_f ( const double  tau) const

Fermionic loop function entering in the calculation of the effective \(Hgg\) and \(H\gamma\gamma\) couplings.

\(A^H_f(\tau)=2\tau [1+(1-\tau)f(\tau)]\)

Parameters
[in]

_form#4314, with \(M\) the mass of the fermion in the loop.

Returns
\(A^H_f(\tau)\)

Definition at line 3295 of file StandardModel/src/StandardModel.cpp.

3295 {
3296 return (2.0 * tau * (1.0 + (1.0 - tau) * f_triangle(tau)));
3297}
gslpp::complex f_triangle(const double tau) const
Loop function entering in the calculation of the effective and couplings.

◆ AH_W()

gslpp::complex StandardModel::AH_W ( const double  tau) const

W loop function entering in the calculation of the effective \(H\gamma\gamma\) coupling.

\(A^H_W(\tau)=-[2+3\tau + 3\tau*(2-\tau) f(\tau)]\)

Parameters
[in]

_form#4314, with \(M\) the mass of the fermion in the loop.

Returns
\(A^H_W(\tau)\)

Definition at line 3299 of file StandardModel/src/StandardModel.cpp.

3299 {
3300 return -(2.0 + 3.0 * tau + 3.0 * tau * (2.0 - tau) * f_triangle(tau));
3301}

◆ AHZga_f()

gslpp::complex StandardModel::AHZga_f ( const double  tau,
const double  lambda 
) const

Fermionic loop function entering in the calculation of the effective \(HZ\gamma\) coupling.

Parameters
[in]

_form#4314, \(\lambda=4 M^2/m_Z^2\), with \(M\) the mass of the fermion in the loop.

Returns
\(A^{HZ\gamma}_f(\tau,\lambda)\)

Definition at line 3303 of file StandardModel/src/StandardModel.cpp.

3303 {
3304 return I_triangle_1(tau, lambda) - I_triangle_2(tau, lambda);
3305}
gslpp::complex I_triangle_1(const double tau, const double lambda) const
Loop function entering in the calculation of the effective coupling.
gslpp::complex I_triangle_2(const double tau, const double lambda) const
Loop function entering in the calculation of the effective coupling.

◆ AHZga_W()

gslpp::complex StandardModel::AHZga_W ( const double  tau,
const double  lambda 
) const

W loop function entering in the calculation of the effective \(HZ\gamma\) coupling.

Parameters
[in]

_form#4314, \(\lambda=4 M^2/m_Z^2\), with \(M\) the mass of the fermion in the loop.

Returns
\(A^{HZ\gamma}_W(\tau,\lambda)\)

Definition at line 3307 of file StandardModel/src/StandardModel.cpp.

3307 {
3308 gslpp::complex tmp;
3309
3310 double tan2w = sW2() / cW2();
3311
3312 tmp = 4.0 * (3.0 - tan2w) * I_triangle_2(tau, lambda);
3313
3314 tmp = tmp + ((1.0 + 2.0 / tau) * tan2w - (5.0 + 2.0 / tau)) * I_triangle_1(tau, lambda);
3315
3316 return sqrt(cW2()) * tmp;
3317}
virtual const double cW2() const

◆ Ale()

const double StandardModel::Ale ( double  mu,
orders  order,
bool  Nf_thr = true 
) const

The running electromagnetic coupling \(\alpha_e(\mu)\) in the \(\overline{MS}\) scheme.

See [Huber:2005ig]

Parameters
[in]murenormalization scale \(\mu\) in GeV
[in]orderorder in the \(\alpha_e\) expansion as defined in the order enum in OrderScheme
[in]Nf_thrflag to activate flavour thresholds. Default: true
Returns
\(\alpha_e(\mu)\) in the \(\overline{MS}\) scheme

Definition at line 776 of file StandardModel/src/StandardModel.cpp.

777{
778 int i, nfAle = (int) Nf(Mz), nfmu = Nf_thr ? (int) Nf(mu) : nfAle;
779 double ale, aletmp, mutmp, aleMz = alphaMz();
780 orders fullord;
781
782 for (i = 0; i < CacheSize; ++i)
783 if ((mu == ale_cache[0][i]) && ((double) order == ale_cache[1][i]) &&
784 (AlsMz == ale_cache[2][i]) && (Mz == ale_cache[3][i]) &&
785 (mut == ale_cache[4][i]) && (mub == ale_cache[5][i]) &&
786 (muc == ale_cache[6][i])
787 && (double) Nf_thr == ale_cache[7][i] && aleMz == ale_cache[8][i])
788 return ale_cache[9][i];
789
790 switch (order)
791 {
792 case FULLNLO:
793 return (Ale(mu, LO, Nf_thr) + Ale(mu, NLO, Nf_thr));
794 case FULLNNLO:
795 return (Ale(mu, LO, Nf_thr) + Ale(mu, NLO, Nf_thr) + Ale(mu, NNLO, Nf_thr));
796 case FULLNNNLO:
797 return (Ale(mu, LO, Nf_thr) + Ale(mu, NLO, Nf_thr) + Ale(mu, NNLO, Nf_thr) + Ale(mu, NNNLO, Nf_thr));
798 case LO:
799 if (nfAle == nfmu)
800 return(AleWithInit(mu, aleMz, Mz, order));
801 case NLO:
802 case NNLO:
803 case NNNLO:
804 if (nfAle == nfmu)
805 return(0.);
806 fullord = FullOrder(order);
807 if (nfAle > nfmu) {
808 mutmp = BelowTh(Mz);
809 aletmp = AleWithInit(mutmp, aleMz, Mz, fullord);
810// aletmp *= (1. - NfThresholdCorrections(mutmp, MassOfNf(nfAle), alstmp, nfAls, fullord)); // WARNING: QED threshold corrections not implemented yet
811 for (i = nfAle - 1; i > nfmu; i--) {
812 mutmp = BelowTh(mutmp - MEPS);
813 aletmp = AleWithInit(mutmp, aletmp, AboveTh(mutmp) - MEPS, fullord);
814// aletmp *= (1. - NfThresholdCorrections(mutmp, MassOfNf(i), aletmp, i, fullord)); // WARNING: QED threshold corrections not implemented yet
815 }
816 ale = AleWithInit(mu, aletmp, AboveTh(mu) - MEPS, order);
817 }
818
819 if (nfAle < nfmu) {
820 mutmp = AboveTh(Mz) - MEPS;
821 aletmp = AleWithInit(mutmp, aleMz, Mz, fullord);
822// alstmp *= (1. + NfThresholdCorrections(mutmp, MassOfNf(nfAls + 1), alstmp, nfAls + 1, fullord)); // WARNING: QED threshold corrections not implemented yet
823 for (i = nfAle + 1; i < nfmu; i++) {
824 mutmp = AboveTh(mutmp) - MEPS;
825 aletmp = AleWithInit(mutmp, aletmp, BelowTh(mutmp) + MEPS, fullord);
826// alstmp *= (1. + NfThresholdCorrections(mutmp, MassOfNf(i + 1), alstmp, i + 1, fullord)); // WARNING: QED threshold corrections not implemented yet
827 }
828 ale = AleWithInit(mu, aletmp, BelowTh(mu) + MEPS, order);
829 }
830
832 ale_cache[0][0] = mu;
833 ale_cache[1][0] = (double) order;
834 ale_cache[2][0] = AlsMz;
835 ale_cache[3][0] = Mz;
836 ale_cache[4][0] = mut;
837 ale_cache[5][0] = mub;
838 ale_cache[6][0] = muc;
839 ale_cache[7][0] = (double) Nf_thr;
840 ale_cache[8][0] = aleMz;
841 ale_cache[9][0] = ale;
842
843 return ale;
844 default:
845 throw std::runtime_error("StandardModel::Ale(): " + orderToString(order) + " is not implemented.");
846 }
847}
@ FULLNNNLO
Definition: OrderScheme.h:40
@ NNLO
Definition: OrderScheme.h:36
@ NNNLO
Definition: OrderScheme.h:37
@ NLO
Definition: OrderScheme.h:35
@ FULLNNLO
Definition: OrderScheme.h:39
@ FULLNLO
Definition: OrderScheme.h:38
double mut
The threshold between six- and five-flavour theory in GeV.
Definition: QCD.h:1021
double muc
The threshold between four- and three-flavour theory in GeV.
Definition: QCD.h:1023
const double BelowTh(const double mu) const
The active flavour threshold below the scale as defined in QCD::Thresholds().
Definition: QCD.cpp:559
const std::string orderToString(const orders order) const
Converts an object of the enum type "orders" to the corresponding string.
Definition: QCD.cpp:95
const double AboveTh(const double mu) const
The active flavour threshold above the scale as defined in QCD::Thresholds().
Definition: QCD.cpp:547
const double Nf(const double mu) const
The number of active flavour at scale .
Definition: QCD.cpp:571
const orders FullOrder(orders order) const
Return the FULLORDER enum corresponding to order.
Definition: QCD.cpp:728
double mub
The threshold between five- and four-flavour theory in GeV.
Definition: QCD.h:1022
void CacheShift(double cache[][5], int n) const
A member used to manage the caching for this class.
const double Ale(double mu, orders order, bool Nf_thr=true) const
The running electromagnetic coupling in the scheme.
const double AleWithInit(double mu, double alsi, double mu_i, orders order) const
double ale_cache[10][CacheSize]
Cache for .
virtual const double alphaMz() const
The electromagnetic coupling at the -mass scale, .
static const int CacheSize
Defines the depth of the cache.
orders
An enum type for orders in QCD.
Definition: OrderScheme.h:33

◆ ale_OS()

const double StandardModel::ale_OS ( const double  mu,
orders  order = FULLNLO 
) const

The running electromagnetic coupling \(\alpha(\mu)\) in the on-shell scheme.

See [Baikov:2012rr].

Parameters
[in]murenormalization scale \(\mu\) in GeV.
[in]orderLO/FULLNLO
Returns
\(\alpha(\mu)\) in the on-shell scheme
Attention
This function is applicable to the scale where the three charged leptons and the five quarks, not the top quark, run in the loops.

Definition at line 604 of file StandardModel/src/StandardModel.cpp.

605{
606 if (mu < 50.0)
607 throw std::runtime_error("out of range in StandardModel::ale_OS()");
608
609 double N = 20.0 / 3.0;
610 double beta1 = N / 3.0;
611 double beta2 = N / 4.0;
612 double alpha_ini = alphaMz();
613 double v = 1.0 + 2.0 * beta1 * alpha_ini / M_PI * log(Mz / mu);
614
615 switch (order) {
616 case LO:
617 return ( alpha_ini / v);
618 case FULLNLO:
619 return ( alpha_ini / v * (1.0 - beta2 / beta1 * alpha_ini / M_PI * log(v) / v));
620 default:
621 throw std::runtime_error("Error in StandardModel::ale_OS()");
622 }
623}
const double v() const
The Higgs vacuum expectation value.

◆ AleWithInit()

const double StandardModel::AleWithInit ( double  mu,
double  alsi,
double  mu_i,
orders  order 
) const
private

Definition at line 849 of file StandardModel/src/StandardModel.cpp.

850{
851 if (fabs(mu - mu_i) < MEPS) return(alei);
852
853 double nf = Nf(mu), alsi = (mu_i == Mz ? AlsMz : Als(mu_i, FULLNNNLO, true, true));
854 double b00e = Beta_e(00, nf), b00s = Beta_s(00, nf);
855 double ve = 1. - b00e * alei / 2. / M_PI * log(mu / mu_i);
856 double logv = log(1. + b00s * alsi / 2. / M_PI * log(mu / mu_i)), logve = log(ve);
857
858 switch (order)
859 {
860 case LO:
861 return (alei / ve);
862 case NLO:
863 return (- alei * alei / 4. / M_PI / ve / ve * (Beta_e(10, nf) / b00e * logve - Beta_e(01, nf) / b00s * logv) );
864 // Higher order terms ? Need to understand eq. (35)
865 case FULLNLO:
866 return (AleWithInit(mu, alei, mu_i, LO) + AleWithInit(mu, alei, mu_i, NLO));
867 default:
868 throw std::runtime_error("StandardModel::AleWithInit(): " + orderToString(order) + " is not implemented.");
869 }
870}
const double Beta_s(int nm, unsigned int nf) const
QCD beta function coefficients including QED corrections - eq. (36) hep-ph/0512066.
const double Als(const double mu, const orders order, const bool Nf_thr, const bool qed_flag) const
The running QCD coupling in the scheme including QED corrections.
const double Beta_e(int nm, unsigned int nf) const
QED beta function coefficients - eq. (36) hep-ph/0512066.

◆ alphaMz()

const double StandardModel::alphaMz ( ) const
virtual

The electromagnetic coupling at the \(Z\)-mass scale, \(\alpha(M_Z^2)=\alpha/(1-\Delta\alpha(M_Z^2))\).

The radiative corrections are included with Dyson resummation:

\[ \alpha(M_Z^2) = \frac{\alpha}{1 - \Delta\alpha(M_Z^2)}. \]

Returns
\(\alpha(M_Z^2)\)

Reimplemented in NPbase, NPSMEFTd6, and NPSMEFTd6General.

Definition at line 937 of file StandardModel/src/StandardModel.cpp.

938{
939 return (ale / (1.0 - DeltaAlpha()));
940// return(1./127.918); // FOR HEFFDF1 TEST: VALUE IN hep-ph/0512066
941// return(1./127.955); // FOR HEFFDF1 TEST: VALUE IN 2007.04191
942}
const double DeltaAlpha() const
The total corrections to the electromagnetic coupling at the -mass scale, denoted as .

◆ alrmoller()

const double StandardModel::alrmoller ( const double  q2,
const double  y 
) const
virtual

The computation of the parity violating asymmetry in Moller scattering.

Parameters
[in]q2the \(Q^2\) of the process
[in]y
Returns
\(A_{LR}\)

Reimplemented in NPbase.

Definition at line 2762 of file StandardModel/src/StandardModel.cpp.

2763{
2764 // functions and inputs
2765 double alrmoller;
2766
2767 // which alfa is this? => alpha(0). is this ale?
2768
2769 // parity violation asymmetry
2770 // --------------------------
2771 alrmoller=-GF*q2*(1.0-y)/(sqrt(2.0)*M_PI*ale*(1.0+pow(y,4)+pow(1.0-y,4)))*Qwemoller(q2,y);
2772
2773 return alrmoller;
2774}
virtual const double alrmoller(const double q2, const double y) const
The computation of the parity violating asymmetry in Moller scattering.
virtual const double Qwemoller(const double q2, const double y) const
The computation of the electron's weak charge.

◆ Als() [1/3]

const double QCD::Als ( const double  mu,
const int  Nf_in,
const orders  order = FULLNLO 
) const

Computes the running strong coupling \(\alpha_s(\mu)\) with \(N_f\) active flavours in the \(\overline{\mathrm{MS}}\) scheme. In the cases of LO, NLO and FULLNLO, the coupling is computed with AlsWithInit(). On the other hand, in the cases of NNLO and FULLNNLO, the coupling is computed with AlsWithLambda().

Parameters
[in]muthe scale \(\mu\) in GeV
[in]Nf_innumber of active flavours
[in]orderorder in the \(\alpha_s\) expansion as defined in OrderScheme
Returns
the strong coupling constant \(\alpha_s(\mu)\) in the \(\overline{\mathrm{MS}}\) scheme with \(N_f\) active flavours

Definition at line 839 of file QCD.cpp.

784{
785 switch (order)
786 {
787 case LO:
788 realorder = order;
789 return AlsByOrder(mu, Nf, LO);
790 case FULLNLO:
791 realorder = order;
792 return (AlsByOrder(mu, Nf, LO) + AlsByOrder(mu, Nf, NLO));
793 case FULLNNLO:
794 realorder = order;
795 return (AlsByOrder(mu, Nf, LO) + AlsByOrder(mu, Nf, NLO) + AlsByOrder(mu, Nf, NNLO));
796 case FULLNNNLO:
797 realorder = order;
798 return (AlsByOrder(mu, Nf, LO) + AlsByOrder(mu, Nf, NLO) + AlsByOrder(mu, Nf, NNLO) + AlsByOrder(mu, Nf, NNNLO));
799 default:
800 throw std::runtime_error("QCD::Als(): " + orderToString(order) + " is not implemented.");
801 }
802}
const double AlsByOrder(const double mu, const orders order=FULLNLO, bool Nf_thr=true) const
Definition: QCD.cpp:804

◆ Als() [2/3]

const double StandardModel::Als ( const double  mu,
const orders  order,
const bool  Nf_thr,
const bool  qed_flag 
) const
inline

The running QCD coupling \(\alpha(\mu)\) in the \(\overline{MS}\) scheme including QED corrections.

See [Huber:2005ig]

Parameters
[in]murenormalization scale \(\mu\) in GeV.
[in]orderorder in the \(\alpha_s\) expansion as defined in OrderScheme
[in]Nf_thrtrue: \(n_f\) = Nf(mu), false: \(n_f\) = Nf(AlsM)
[in]qed_flaginclude \(\alpha_e\) corrections to the requested order in \(\alpha_s\). The \(\alpha_s\alpha_e\) term is included if NNNLO is requested. Default: false
Returns
\(\alpha(\mu)\) in the \(\overline{MS}\) scheme

Definition at line 1088 of file StandardModel.h.

1089 {
1090 if (qed_flag && order == FULLNNNLO)
1091 return AlsE(mu, order, Nf_thr);
1092
1093 return Als(mu, order, Nf_thr);
1094 }
const double AlsE(double mu, orders order, bool Nf_thr) const

◆ Als() [3/3]

const double QCD::Als ( const double  mu,
const orders  order = FULLNLO,
const bool  Nf_thr = true 
) const

Definition at line 826 of file QCD.cpp.

763{
764 switch (order)
765 {
766 case LO:
767 realorder = order;
768 return AlsByOrder(mu, LO, Nf_thr);
769 case FULLNLO:
770 realorder = order;
771 return (AlsByOrder(mu, LO, Nf_thr) + AlsByOrder(mu, NLO, Nf_thr));
772 case FULLNNLO:
773 realorder = order;
774 return (AlsByOrder(mu, LO, Nf_thr) + AlsByOrder(mu, NLO, Nf_thr) + AlsByOrder(mu, NNLO, Nf_thr));
775 case FULLNNNLO:
776 realorder = order;
777 return (AlsByOrder(mu, LO, Nf_thr) + AlsByOrder(mu, NLO, Nf_thr) + AlsByOrder(mu, NNLO, Nf_thr) + AlsByOrder(mu, NNNLO, Nf_thr));
778 default:
779 throw std::runtime_error("QCD::Als(): " + orderToString(order) + " is not implemented.");
780 }
781}

◆ AlsE()

const double StandardModel::AlsE ( double  mu,
orders  order,
bool  Nf_thr 
) const
private

Definition at line 673 of file StandardModel/src/StandardModel.cpp.

674{
675 switch (order)
676 {
677 case FULLNNNLO:
678 realorder = order;
679 return (AlsByOrder(mu, LO, Nf_thr) + AlsByOrder(mu, NLO, Nf_thr) + AlsByOrder(mu, NNLO, Nf_thr) + AlsEByOrder(mu, NNNLO, Nf_thr));
680 default:
681 throw std::runtime_error("StandardModel::AlsE(): " + orderToString(order) + " is not implemented.");
682 }
683}
const double AlsEByOrder(double mu, orders order, bool Nf_thr) const

◆ AlsEByOrder()

const double StandardModel::AlsEByOrder ( double  mu,
orders  order,
bool  Nf_thr 
) const
private

Definition at line 685 of file StandardModel/src/StandardModel.cpp.

686{
687 int i, nfAls = (int) Nf(Mz), nfmu = Nf_thr ? (int) Nf(mu) : nfAls;
688 double als, alstmp, mutmp;
689 orders fullord;
690
691 for (i = 0; i < CacheSize; ++i)
692 if ((mu == als_cache[0][i]) && ((double) order == als_cache[1][i]) &&
693 (AlsMz == als_cache[2][i]) && (Mz == als_cache[3][i]) &&
694 (mut == als_cache[4][i]) && (mub == als_cache[5][i]) &&
695 (muc == als_cache[6][i]) && (double) true == als_cache[7][i]
696 && (double) Nf_thr == als_cache[8][i] && alphaMz() == als_cache[9][i])
697 return als_cache[10][i];
698
699 switch (order)
700 {
701 case NNNLO:
702 if (nfAls == nfmu)
703 als = AlsEWithInit(mu, AlsMz, Mz, nfAls, order);
704 fullord = FullOrder(order);
705 if (nfAls > nfmu) {
706 mutmp = BelowTh(Mz);
707 alstmp = AlsEWithInit(mutmp, AlsMz, Mz, nfAls, realorder);
708 alstmp *= (1. - NfThresholdCorrections(mutmp, MassOfNf(nfAls), alstmp, nfAls, fullord)); // WARNING: QED threshold corrections not implemented yet
709 for (i = nfAls - 1; i > nfmu; i--) {
710 mutmp = BelowTh(mutmp - MEPS);
711 alstmp = AlsEWithInit(mutmp, alstmp, AboveTh(mutmp) - MEPS, i, realorder);
712 alstmp *= (1. - NfThresholdCorrections(mutmp, MassOfNf(i), alstmp, i, fullord)); // WARNING: QED threshold corrections not implemented yet
713 }
714 als = AlsEWithInit(mu, alstmp, AboveTh(mu) - MEPS, nfmu, order);
715 }
716
717 if (nfAls < nfmu) {
718 mutmp = AboveTh(Mz) - MEPS;
719 alstmp = AlsEWithInit(mutmp, AlsMz, Mz, nfAls, realorder);
720 alstmp *= (1. + NfThresholdCorrections(mutmp, MassOfNf(nfAls + 1), alstmp, nfAls + 1, fullord)); // WARNING: QED threshold corrections not implemented yet
721 for (i = nfAls + 1; i < nfmu; i++) {
722 mutmp = AboveTh(mutmp) - MEPS;
723 alstmp = AlsEWithInit(mutmp, alstmp, BelowTh(mutmp) + MEPS, i, realorder);
724 alstmp *= (1. + NfThresholdCorrections(mutmp, MassOfNf(i + 1), alstmp, i + 1, fullord)); // WARNING: QED threshold corrections not implemented yet
725 }
726 als = AlsEWithInit(mu, alstmp, BelowTh(mu) + MEPS, nfmu, order);
727 }
728
730 als_cache[0][0] = mu;
731 als_cache[1][0] = (double) order;
732 als_cache[2][0] = AlsMz;
733 als_cache[3][0] = Mz;
734 als_cache[4][0] = mut;
735 als_cache[5][0] = mub;
736 als_cache[6][0] = muc;
737 als_cache[7][0] = (double) true;
738 als_cache[8][0] = (double) Nf_thr;
739 als_cache[9][0] = alphaMz();
740 als_cache[10][0] = als;
741
742 return als;
743 default:
744 throw std::runtime_error("StandardModel::AlsEByOrder(): " + orderToString(order) + " is not implemented.");
745 }
746}
const double NfThresholdCorrections(double mu, double M, double als, int nf, orders order) const
Threshold corrections in matching with from eq. (34) of hep-ph/0512060.
Definition: QCD.cpp:709
const double MassOfNf(int nf) const
The Mbar mass of the heaviest quark in the theory with Nf active flavour.
Definition: QCD.cpp:745
double als_cache[11][CacheSize]
Cache for .
const double AlsEWithInit(double mu, double alsi, double mu_i, const int nf_i, orders order) const

◆ AlsEWithInit()

const double StandardModel::AlsEWithInit ( double  mu,
double  alsi,
double  mu_i,
const int  nf_i,
orders  order 
) const
private

Definition at line 748 of file StandardModel/src/StandardModel.cpp.

749{
750 double nf = (double) nf_i, alei = Ale(mu_i, FULLNLO); // CHANGE ME!
751 double b00s = Beta_s(00, nf), b00e = Beta_e(00, nf);
752 double v = 1. + b00s * alsi / 2. / M_PI * log(mu / mu_i);
753 double ve = 1. - b00e * alei / 2. / M_PI * log(mu / mu_i);
754 double logv = log(v), logve = log(ve);
755 double rho = 1. / (1. + b00e * alei / b00s / alsi);
756 double als = AlsWithInit(mu, alsi, mu_i, nf, order);
757 double b01s = Beta_s(01,nf), b01s00e = b01s / b00e;
758
759 switch (order)
760 {
761 case NNNLO:
762 als += alsi * alsi * alei / 4. / 4. / M_PI / M_PI / v / v / ve * (Beta_s(02, nf) / b00e *
763 (ve - 1.) + Beta_s(11, nf) / b00s * rho * ve * (logve - logv) + b01s00e * Beta_e(10, nf) /
764 b00e * (logve - ve + 1.) + b01s * Beta_s(10, nf) / b00s / b00s * rho * logv +
765 b01s00e * Beta_e(01, nf) / b00s * (rho * ve * (logv - logve) - logv));
766 break;
767 case FULLNNNLO:
768 return (AlsWithInit(mu, alsi, mu_i, nf_i, LO) + AlsWithInit(mu, alsi, mu_i, nf_i, NLO)+ AlsWithInit(mu, alsi, mu_i, nf_i, NNLO) + AlsEWithInit(mu, alsi, mu_i, nf_i, NNNLO));
769 default:
770 throw std::runtime_error("StandardModel::AlsEWithInit(): " + orderToString(order) + " is not implemented.");
771 }
772
773 return (als);
774}
const double AlsWithInit(const double mu, const double alsi, const double mu_i, const int nf, const orders order) const
Computes the running strong coupling from in the scheme, where it is forbidden to across a flavour...
Definition: QCD.cpp:627

◆ Alstilde5()

const double StandardModel::Alstilde5 ( const double  mu) const

The value of \(\frac{\alpha_s^{\mathrm{FULLNLO}}}{4\pi}\) at any scale \(\mu\) with the number of flavours \(n_f = 4\) and full EW corrections.

Parameters
[in]muthe scale at which \(\alpha_s\) has to be computed
Returns
\(\alpha_s^{\mathrm{FULLNLO}}(\mu)\) with \(n_f = 4\5\)

Definition at line 944 of file StandardModel/src/StandardModel.cpp.

945{
946 double mu_0 = Mz;
947 double alphatilde_e = alphaMz()/4./M_PI;
948 double alphatilde_s = AlsMz/4./M_PI;
949 unsigned int nf = 5;
950
951 double B00S = Beta0(nf), B10S = Beta1(nf), B20S = Beta2(nf), B30S = gsl_sf_zeta_int(3) * 352864./81. - 598391./1458,
952 B01S = -22./9., B11S = -308./27., B02S = 4945./243.;
953
954 double B00E = 80./9., B01E = 176./9., B10E = 464./27.;
955
956 double B10soB00s = B10S / B00S;
957 double B01soB00e = B01S/B00E;
958
959 double vs= 1. + 2. * B00S * alphatilde_s * log(mu/ mu_0);
960 double ve= 1. - 2. * B00E * alphatilde_e * log(mu/ mu_0);
961 double ps= B00S * alphatilde_s /(B00S * alphatilde_s + B00E * alphatilde_e);
962
963 double logve = log(ve);
964 double logvs = log(vs);
965 double logeos = log(ve/vs);
966 double logsoe = log(vs/ve);
967 double asovs = alphatilde_s/vs;
968 double aeove = alphatilde_e/ve;
969
970 double result = 0;
971
972 result = asovs - pow(asovs, 2) * (logvs * B10soB00s - logve * B01soB00e)
973 + pow(asovs, 3) * ((1. - vs) * B20S / B00S + B10soB00s * B10soB00s * (logvs * logvs - logvs
974 + vs - 1.) + B01soB00e * B01soB00e * logve * logve + (-2. * logvs * logve
975 + ps * ve * logve) * B01S * B10S/(B00E * B00S))
976 + pow(asovs, 4) * (0.5 * B30S *(1. - vs * vs)/ B00S + ((2. * vs - 3.) * logvs + vs * vs
977 - vs) * B20S * B10soB00s /(B00S) + B10soB00s * B10soB00s * B10soB00s * (- pow(logvs,3)
978 + 5. * pow(logvs,2) / 2. + 2. * (1. - vs) * logvs - (vs - 1.) * (vs - 1.)* 0.5))
979 + pow(asovs, 2) * (aeove) * ((ve - 1.) * B02S / B00E
980 + ps * ve * logeos * B11S /B00S +(logve - ve + 1.) * B01soB00e * B10E/(B00E)
981 + logvs * ps * B01S * B10soB00s/(B00S) +(logsoe * ve * ps - logvs) * B01soB00e * B01E/( B00S));
982 return (result);
983}
const double Beta2(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:611
const double Beta1(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:606
const double Beta0(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:601

◆ amuon()

const double StandardModel::amuon ( ) const
virtual

The computation of the anomalous magnetic moment of the muon \(a_\mu=(g_\mu-2)/2\).

Returns
\(a_\mu=(g_\mu-2)/2\)

Reimplemented in NPbase.

Definition at line 2434 of file StandardModel/src/StandardModel.cpp.

2435{
2436
2437// output
2438 double amu;
2439
2440// -----------------------------------------------------------------
2441// qed contributions
2442 double amuqed,alfa0pi;
2443
2444// ew contributions
2445 double amuew,amuew1,amuew2b,amuew2f,amuew2,amuew3,cft,cf,corr1amuew2, corr2amuew2,corrwaamuew2,al,aq,b1; //,b2;
2446
2447// qcd contributions
2448 double amuhad,amuhhovp,amuhholbl,amuhho,amuhlo;
2449
2450// -----------------------------------------------------------------
2451// numerical constants
2452 const double sn2=0.2604341;
2453
2454// -----------------------------------------------------------------
2455// SM parameters
2456
2457// light quark masses. constituent masses
2458 const double umass=0.3;
2459 const double dmass=0.3;
2460 const double smass=0.5;
2461
2462 const double mum=leptons[MU].getMass(),taum=leptons[TAU].getMass();
2463 const double cqm=quarks[CHARM].getMass(),bqm=quarks[BOTTOM].getMass();
2464
2465// all fermion masses (constituent masses for u,d,s. for the other from model)
2466 double fermmass[9]={leptons[ELECTRON].getMass(),mum,taum,
2467 dmass,umass,
2468 smass,cqm,
2469 bqm,mtpole};
2470
2471// w mass and on-shell weak angle
2472 double MwSM, s2;
2473
2474// running of alfa_qed and dummy variable
2475 double aqed;
2476
2477// for the 2-loop bosonic corrections
2478 double a2l[4]={0.,0.,0.,0.},b2l[4]={0.,0.,0.,0.},sw2l[4]={0.,0.,0.,0.};
2479
2480// for the 2-loop corrections from the renormalization of weak angle
2481 double c2lren[6]={0.,0.,0.,0.,0.,0.};
2482
2483// w mass
2484 MwSM=Mw();
2485
2486 s2=1.0 - MwSM*MwSM/Mz/Mz;
2487
2488//------------------------------------------------------------------
2489// qed contribution to amu (arxiv: hep-ph/0606174)
2490 alfa0pi=ale/M_PI;
2491
2492 amuqed=alfa0pi*(0.5+alfa0pi*(0.765857410+alfa0pi*(24.05050964+
2493 + alfa0pi*(130.8055+663.0*alfa0pi))));
2494
2495//-----------------------------------------------------------------
2496// one-loop ew correction(phys.rev.lett. 76,3267 (1996))
2497
2498 amuew1=5.0*GF*mum*mum/(24.0*sqrt(2.0)*M_PI*M_PI)*(1.0+
2499 + 0.2*(1.0-4.0*s2)*(1.0-4.0*s2));
2500
2501//-----------------------------------------------------------------
2502// two-loop computation
2503
2504// these depend on aqed and since we are going to include also three-loop
2505// effects we need to include in the two-loop results the running of aqed at
2506// 1-loop up to the scale mum
2507//-----------------------------------------------------------------
2508// running of alpha em down to mu mass (1-loop)
2509
2510 aqed = 1.0/ale + 2.0 * log(fermmass[0]/mum)/3.0/M_PI;
2511
2512 aqed = 1.0/aqed;
2513
2514//-----------------------------------------------------------------
2515// two-loop ew bosonic correction(phys.rev.lett. 76,3267 (1996))
2516
2517// previous definitions
2518 a2l[0]=19.0/36.0-99.0*sn2/8.0-1.0*2.0*log(mHl/MwSM)/24.0;
2519
2520 b2l[0]=155.0/192.0+3.0*M_PI*M_PI/8.0-9.0*sn2/8.0+3.0*2.0*pow(log(mHl/MwSM),2)/2.0-21.0*2.0*log(mHl/MwSM)/16.0;
2521
2522 sw2l[0]=1.0/s2;
2523
2524 a2l[1]=-859.0/18.0+11.0*M_PI/sqrt(3.0)+20.0*M_PI*M_PI/9.0+ 393.0*sn2/8.0-65.0*2.0*log(MwSM/mum)/9.0+ 31.0*2.0*log(mHl/MwSM)/72.0;
2525
2526 b2l[1]=433.0/36.0+5.0*M_PI*M_PI/24.0-51.0*sn2/8.0+ 3.0*4.0*pow(log(mHl/MwSM),2)/8.0+9.0*2.0*log(mHl/MwSM)/4.0;
2527
2528 sw2l[1]=1.0;
2529
2530 a2l[2]=165169.0/1080.0-385.0*M_PI/(6.0*sqrt(3.0))-29.0*M_PI*M_PI/6.0+ 33.0*sn2/8.0+92.0*2.0*log(MwSM/mum)/9.0- 133.0*2.0*log(mHl/MwSM)/72.0;
2531
2532 b2l[2]=-431.0/144.0+3.0*M_PI*M_PI/8.0+315.0*sn2/8.0+ 3.0*4.0*pow(log(mHl/MwSM),2)/2.0-11.0*2.0*log(mHl/MwSM)/8.0;
2533
2534 sw2l[2]=s2;
2535
2536 a2l[3]=-195965.0/864.0+265.0*M_PI/(3.0*sqrt(3.0))+163.0*M_PI*M_PI/18.0+ 223.0*sn2/12.0-184.0*2.0*log(MwSM/mum)/9.0- 5.0*2.0*log(mHl/MwSM)/8.0;
2537
2538 b2l[3]=433.0/216.0+13.0*M_PI*M_PI/24.0+349.0*sn2/24.0+ 21.0*4.0*pow(log(mHl/MwSM),2)/8.0-49.0*2.0*log(mHl/MwSM)/12.0;
2539
2540 sw2l[3]=s2*s2;
2541
2542// computation
2543
2544 amuew2b=0.0;
2545
2546 for (int i = 0; i < 4; ++i) {
2547 amuew2b=amuew2b+a2l[i]*sw2l[i]+(MwSM*MwSM/mHl/mHl)*b2l[i]*sw2l[i];
2548 }
2549
2550// the contribution with the running of aqed up to the mu scale
2551 amuew2b=mum*mum*aqed*GF*amuew2b/(8.0*sqrt(2.0)*M_PI*M_PI*M_PI);
2552
2553//-----------------------------------------------------------------
2554// two-loop ew fermionic correction(phys.rev.d 52,r2619(1995)
2555
2556// contribution from higgs boson diagram
2557 if (mHl < (mtpole-10.0)) {
2558 cft=-104.0/45.0-16.0*2.0*log(mtpole/mHl)/15.0;
2559 } else if (mHl > (mtpole+10)) {
2560 cft=-(mtpole*mtpole/mHl/mHl)*(24.0/5.0+8.0*M_PI*M_PI/15.0+
2561 + 8.0/5.0*pow(2.0*log(mHl/mtpole)-1.0,2));
2562 } else {
2563 cft=-(32.0/5.0)*(1.0-9.0*sn2/4.0);
2564 }
2565
2566 cf=pow((umass*cqm*Mz),(4.0/3.0));
2567
2568 cf=cf/(pow((dmass*smass*bqm),(1.0/3.0))*mum*mum*taum);
2569
2570 cf=-18.0*log(cf)/5.0-3.0*mtpole*mtpole/(16.0*s2*MwSM*MwSM)- 3.0*2.0*log(mtpole/MwSM)/(10.0*s2)- 8.0*2.0*log(mtpole/Mz)/5.0-41.0/5.0-7.0/(10.0*s2)+ 8.0*M_PI*M_PI/15.0+cft;
2571
2572// the contribution with the running of aqed up to the mu scale
2573 amuew2f=5.0*GF*mum*mum*cf*aqed/(24.0*sqrt(2.0)*M_PI*M_PI*M_PI);
2574
2575//-----------------------------------------------------------------
2576// corrections from hadronic loops (phys.rev.d 67,073006(2003))
2577// i also include the running here even though in the previous reference seems that it is not included
2578// first family (eqs. (60) and (61))
2579 corr1amuew2=-aqed*GF*mum*mum/(8.0*M_PI*M_PI*M_PI*sqrt(2.0))*(8.41- log(pow(umass,8)/(pow(mum,6)*pow(dmass,2)))-17.0/2.0);
2580// second family (eqs. (65) and (66))
2581 corr2amuew2=-aqed*GF*mum*mum/(8.0*M_PI*M_PI*M_PI*sqrt(2.0))*(17.1- log(pow(cqm,8)/(pow(mum,6)*pow(smass,2)))-47.0/6.0+8.0*M_PI*M_PI/9.0);
2582
2583//-----------------------------------------------------------------
2584// corrections from the renormalization of the weak mixing
2585// terms prop. to (1-4s2) included in eq. (7) of phys.rev.d 67,073006(2003)
2586// and neglected in the previous references
2587
2588 corrwaamuew2=-43.0*31.0*(1.0-4.0*s2)*(1.0-4.0*s2)/(215.0*3.0)*log(Mz/mum);
2589
2590 c2lren[0]=(72.0/135.0)*(-1.0+2.0*s2)*(1.0-4.0*s2); //leptons
2591 c2lren[1]=(72.0/135.0)*(-1.0+2.0*s2/3.0)*(1.0-4.0*s2); //d-quark
2592 c2lren[2]=-(144.0/135.0)*(1.0-4.0*s2/3.0)*(1.0-4.0*s2); //u-quark
2593 c2lren[3]=c2lren[1];//d-quark
2594 c2lren[4]=c2lren[2]; //u-quark
2595 c2lren[5]=c2lren[1]; //d-quark
2596
2597 for (int i = 2; i < 8; ++i) {
2598 corrwaamuew2=corrwaamuew2+c2lren[i-2]*log(Mz/fermmass[i]);
2599 }
2600
2601 corrwaamuew2=5*GF*mum*mum*aqed/(24.0*sqrt(2.0)*M_PI*M_PI*M_PI)*corrwaamuew2;
2602
2603// finally i also add the small correction to the eq.8
2604 corrwaamuew2=corrwaamuew2-0.2e-11;
2605
2606//-----------------------------------------------------------------
2607// total 2-loop ew contribution
2608 amuew2=amuew2b+amuew2f+corr1amuew2+corr2amuew2+corrwaamuew2;
2609
2610//-----------------------------------------------------------------
2611// three-loop ew correction(phys.rev.d 67,073006(2003)
2612
2613 al=2789.0*log(Mz/mum)*log(Mz/mum)/90.0- 302.0*log(Mz/taum)*log(Mz/taum)/45.0+ 72.0*log(Mz/taum)*log(Mz/mum)/5.0;
2614
2615 aq=-2662.0*log(Mz/bqm)*log(Mz/bqm)/1215.0+11216.0*log(Mz/cqm)*log(Mz/cqm)/1215.0+1964.0*log(Mz/umass)*log(Mz/umass)/405.0+24.0*log(Mz/bqm)*log(Mz/mum)/5.0-96.0*log(Mz/cqm)*log(Mz/mum)/5.0-48.0*log(Mz/umass)*log(Mz/mum)/5.0+32.0*log(Mz/bqm)*log(Mz/cqm)/405.0+32.0*log(Mz/bqm)*log(Mz/umass)/135.0;
2616
2617 b1=-179.0/45.0*(log(Mz/bqm)*log(Mz/bqm)/3.0+log(Mz/taum)*log(Mz/taum)+4.0*log(Mz/cqm)*log(Mz/cqm)/3.0+2.0*log(Mz/umass)*log(Mz/umass)+2.0*log(Mz/mum)*log(Mz/mum))+2.0/5.0*(log(bqm/taum)*log(bqm/taum)+4.0/3.0*log(bqm/cqm)*log(bqm/cqm)+2.0*log(bqm/umass)*log(bqm/umass)+2.0*log(bqm/mum)*log(bqm/mum) )-8.0/5.0*(2.0*log(cqm/umass)*log(cqm/umass)+2.0*log(cqm/mum)*log(cqm/mum))+6.0/5.0*(4.0/3.0*log(taum/cqm)*log(taum/cqm)+2.0*log(taum/umass)*log(taum/umass)+2.0*log(taum/mum)*log(taum/mum))-8.0*log(umass/mum)*log(umass/mum)/5.0;
2618
2619 // b2 is not used, as it can be absorved in the two loop part if alpha(m_mu) is used instead of alpha(Mz), as done above
2620 // b2=2.0/5.0*(2.0*log(Mz/mum)+2.0*log(Mz/umass)+4.0*log(Mz/cqm)/3.0+log(Mz/taum)+log(Mz/bqm)/3.0)*(215.0*log(Mz/mum)/9.0-4.0*log(Mz/umass)-8.0*log(Mz/cqm)+6.0*log(Mz/taum)+2.0*log(Mz/bqm));
2621
2622// the final correction(it is implied aqed at mum for the 2-loop
2623// correction
2624
2625 amuew3=amuew1*(ale*ale/M_PI/M_PI)*(al+aq+b1);
2626
2627//-----------------------------------------------------------------
2628// total ew correction
2629
2630 amuew=amuew1+amuew2+amuew3;
2631
2632//-----------------------------------------------------------------
2633// hadronic contributions (arxiv: 0908.4300 & 1001.5401 [hep-ph])
2634
2635// leading order: vacuum polarization (arxiv: 0908.4300 [hep-ph])
2636 amuhlo=6955.e-11;
2637
2638// higher order: vacuum polarization
2639 amuhhovp=-97.9e-11;
2640
2641// higher order: light-by-light
2642 amuhholbl=105.e-11;
2643
2644 amuhho=amuhhovp+amuhholbl;
2645
2646// total hadronic contribution
2647
2648 amuhad=amuhlo+amuhho;
2649
2650//-----------------------------------------------------------------
2651// final value for the muon (g-2)/2
2652
2653 amu=amuqed+amuew+amuhad;
2654
2655//-----------------------------------------------------------------
2656
2657 return amu;
2658
2659}
@ BOTTOM
Definition: QCD.h:329
@ CHARM
Definition: QCD.h:326
Particle quarks[6]
The vector of all SM quarks.
Definition: QCD.h:1027
A class for , the pole mass of the top quark.
Definition: masses.h:164

◆ Beta_e()

const double StandardModel::Beta_e ( int  nm,
unsigned int  nf 
) const

QED beta function coefficients - eq. (36) hep-ph/0512066.

Parameters
nmpowers of alpha_s and alpha_e as an integer
nfnumber of active flavor
Returns
coefficient of the QED beta function

Definition at line 653 of file StandardModel/src/StandardModel.cpp.

654{
655 unsigned int nu = nf % 2 == 0 ? nf / 2 : nf / 2;
656 unsigned int nd = nf % 2 == 0 ? nf / 2 : 1 + nf / 2;
657 double Qu = 2. / 3., Qd = -1. / 3., Qbar2 = nu * Qu * Qu + nd * Qd * Qd,
658 Qbar4 = nu * Qu * Qu * Qu * Qu + nd * Qd * Qd * Qd * Qd;
659
660 switch(nm)
661 {
662 case 00:
663 return(4./3. * (Qbar2 * Nc + 3.)); // QL^2 = 1
664 case 10:
665 return(4. * (Qbar4 * Nc + 3.));
666 case 01:
667 return(4. * CF * Nc * Qbar2);
668 default:
669 throw std::runtime_error("StandardModel::Beta_e(): case not implemented");
670 }
671}
double CF
Definition: QCD.h:1026
double Nc
The number of colours.
Definition: QCD.h:1025

◆ Beta_s()

const double StandardModel::Beta_s ( int  nm,
unsigned int  nf 
) const

QCD beta function coefficients including QED corrections - eq. (36) hep-ph/0512066.

Parameters
nmpowers of alpha_s and alpha_e as an integer
nfnumber of active flavor
Returns
coefficient of the QCD beta function

Definition at line 625 of file StandardModel/src/StandardModel.cpp.

626{
627 unsigned int nu = nf % 2 == 0 ? nf / 2 : nf / 2;
628 unsigned int nd = nf % 2 == 0 ? nf / 2 : 1 + nf / 2;
629 double Qu = 2. / 3., Qd = -1. / 3., Qbar2 = nu * Qu * Qu + nd * Qd * Qd,
630 Qbar4 = nu * Qu * Qu * Qu * Qu + nd * Qd * Qd * Qd * Qd;
631
632 switch(nm)
633 {
634 case 00:
635 return(Beta0((double) nf));
636 case 10:
637 return(Beta1((double) nf));
638 case 20:
639 return(Beta2((double) nf));
640 case 30:
641 return(Beta3((double) nf));
642 case 01:
643 return(-4. * TF * Qbar2 );
644 case 11:
645 return((4. * CF - 8. * CA) * TF * Qbar2 );
646 case 02:
647 return(11./3. * TF * Qbar2 * Beta_e(00, nf) + 2. * TF * Qbar4);
648 default:
649 throw std::runtime_error("StandardModel::Beta_s(): case not implemented");
650 }
651}
double CA
Definition: QCD.h:1026
double TF
Definition: QCD.h:1026
const double Beta3(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:618

◆ BrHtobb()

const double StandardModel::BrHtobb ( ) const
virtual

The Br \((H\to b \bar{b})\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
Br \((H\to b \bar{b})\)

Definition at line 3690 of file StandardModel/src/StandardModel.cpp.

3691{
3692 return GammaHtobb()/GammaHTot();
3693}
virtual const double GammaHtobb() const
The in the Standard Model.
virtual const double GammaHTot() const
The total Higgs width in the Standard Model.

◆ BrHtocc()

const double StandardModel::BrHtocc ( ) const
virtual

The Br \((H\to c \bar{c})\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
Br \((H\to c \bar{c})\)

Definition at line 3680 of file StandardModel/src/StandardModel.cpp.

3681{
3682 return GammaHtocc()/GammaHTot();
3683}
virtual const double GammaHtocc() const
The in the Standard Model.

◆ BrHtogaga()

const double StandardModel::BrHtogaga ( ) const
virtual

The Br \((H\to \gamma \gamma)\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
Br \((H\to \gamma \gamma)\)

Definition at line 3665 of file StandardModel/src/StandardModel.cpp.

3666{
3667 return GammaHtogaga()/GammaHTot();
3668}
virtual const double GammaHtogaga() const
The in the Standard Model.

◆ BrHtogg()

const double StandardModel::BrHtogg ( ) const
virtual

The Br \(\(H\to gg)\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
Br \((H\to gg)\)

Definition at line 3645 of file StandardModel/src/StandardModel.cpp.

3646{
3647 return GammaHtogg()/GammaHTot();
3648}
virtual const double GammaHtogg() const
The in the Standard Model.

◆ BrHtomumu()

const double StandardModel::BrHtomumu ( ) const
virtual

The Br \((H\to \mu^+ \mu^-)\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
Br \((H\to \mu^+ \mu^-)\)

Definition at line 3670 of file StandardModel/src/StandardModel.cpp.

3671{
3672 return GammaHtomumu()/GammaHTot();
3673}
virtual const double GammaHtomumu() const
The in the Standard Model.

◆ BrHtoss()

const double StandardModel::BrHtoss ( ) const
virtual

The Br \((H\to s \bar{s})\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
Br \((H\to s \bar{s})\)

Definition at line 3685 of file StandardModel/src/StandardModel.cpp.

3686{
3687 return GammaHtoss()/GammaHTot();
3688}
virtual const double GammaHtoss() const
The in the Standard Model.

◆ BrHtotautau()

const double StandardModel::BrHtotautau ( ) const
virtual

The Br \((H\to \tau^+ \tau^-)\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
Br \((H\to \tau^+ \tau^-)\)

Definition at line 3675 of file StandardModel/src/StandardModel.cpp.

3676{
3677 return GammaHtotautau()/GammaHTot();
3678}
virtual const double GammaHtotautau() const
The in the Standard Model.

◆ BrHtoWWstar()

const double StandardModel::BrHtoWWstar ( ) const
virtual

The Br \((H\to W W^*)\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
Br \((H\to W W^*)\)

Definition at line 3655 of file StandardModel/src/StandardModel.cpp.

3656{
3657 return GammaHtoWWstar()/GammaHTot();
3658}
virtual const double GammaHtoWWstar() const
The in the Standard Model.

◆ BrHtoZga()

const double StandardModel::BrHtoZga ( ) const
virtual

The Br \((H\to Z \gamma)\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
Br \((H\to Z \gamma)\)

Definition at line 3660 of file StandardModel/src/StandardModel.cpp.

3661{
3662 return GammaHtoZga()/GammaHTot();
3663}
virtual const double GammaHtoZga() const
The in the Standard Model.

◆ BrHtoZZstar()

const double StandardModel::BrHtoZZstar ( ) const
virtual

The Br \((H\to Z Z^*)\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
Br \((H\to Z Z^*)\)

Definition at line 3650 of file StandardModel/src/StandardModel.cpp.

3651{
3652 return GammaHtoZZstar()/GammaHTot();
3653}
virtual const double GammaHtoZZstar() const
The in the Standard Model.

◆ BrW()

const double StandardModel::BrW ( const Particle  fi,
const Particle  fj 
) const
virtual

The branching ratio of the \(W\) boson decaying into a SM fermion pair, \(Br(W\to f_i f_j)\).

Returns
\(Br(W\to f_i f_j)\) in GeV

Reimplemented in NPbase, NPSMEFTd6, and NPSMEFTd6General.

Definition at line 1282 of file StandardModel/src/StandardModel.cpp.

1283{
1284 double GammW = GammaW();
1285 double GammWij = GammaW(fi, fj);
1286
1287 return GammWij/GammW;
1288}
virtual const double GammaW() const
The total width of the boson, .

◆ c02()

const double StandardModel::c02 ( ) const

The square of the cosine of the weak mixing angle \(c_0^2\) defined without weak radiative corrections.

The quantity \(c_0^2\) is given by

\[ c_0^2 = 1 - s_0^2\,, \]

where \(s_0^2\) is defined in s02().

See [Altarelli:1990zd] and [Altarelli:1991fk].

Returns
\(s_0^2\)

Definition at line 1013 of file StandardModel/src/StandardModel.cpp.

1014{
1015 return ( 1.0 - s02());
1016}
const double s02() const
The square of the sine of the weak mixing angle defined without weak radiative corrections.

◆ checkEWPOscheme()

bool StandardModel::checkEWPOscheme ( const std::string  scheme) const
inlineprotected

A method to check if a given scheme name in string form is valid.

Parameters
[in]schemescheme name for \(M_W\), \(\rho_Z^f\) or \(\kappa_Z^f\)
Returns
a boolean that is true if the scheme name is valid

Definition at line 3500 of file StandardModel.h.

3501 {
3502 if (scheme.compare("NORESUM") == 0
3503 || scheme.compare("OMSI") == 0
3504 || scheme.compare("INTERMEDIATE") == 0
3505 || scheme.compare("OMSII") == 0
3506 || scheme.compare("APPROXIMATEFORMULA") == 0)
3507 return true;
3508 else
3509 return false;
3510 }

◆ CheckFlags()

bool StandardModel::CheckFlags ( ) const
virtual

A method to check the sanity of the set of model flags.

Returns
a boolean that is true if the set of model flags is sane

Reimplemented from QCD.

Definition at line 546 of file StandardModel/src/StandardModel.cpp.

547{
548 return (QCD::CheckFlags());
549}
virtual bool CheckFlags() const
A method to check the sanity of the set of model flags.
Definition: QCD.cpp:517

◆ CheckParameters()

bool StandardModel::CheckParameters ( const std::map< std::string, double > &  DPars)
virtual

A method to check if all the mandatory parameters for StandardModel have been provided in model initialization.

Parameters
[in]DParsa map of the parameters that are being updated in the Monte Carlo run (including parameters that are varied and those that are held constant)
Returns
a boolean that is true if the execution is successful

Reimplemented from QCD.

Reimplemented in CMFV, FlavourWilsonCoefficient, FlavourWilsonCoefficient_DF2, LoopMediators, NPDF2, RealWeakEFTCC, RealWeakEFTLFV, GeneralSUSY, GeorgiMachacek, LeftRightSymmetricModel, MFV, HiggsChiral, HiggsKigen, NPEpsilons, NPEpsilons_pureNP, NPHiggs, NPSMEFTd6, NPSTU, NPSTUVWXY, NPSTUZbbbarLR, NPZbbbar, NPZbbbarLinearized, SigmaBR, pMSSM, SUSY, SUSYMassInsertion, THDM, and THDMW.

Definition at line 363 of file StandardModel/src/StandardModel.cpp.

364{
365 for (int i = 0; i < NSMvars; i++) {
366 if (DPars.find(SMvars[i]) == DPars.end()) {
367 std::cout << "ERROR: missing mandatory SM parameter " << SMvars[i] << std::endl;
370 }
371 }
372 return (QCD::CheckParameters(DPars));
373}
std::map< std::string, double > DPars
Definition: Minimal.cpp:11
void addMissingModelParameter(const std::string &missingParameterName)
Definition: Model.h:250
void raiseMissingModelParameterCount()
Definition: Model.h:260
virtual bool CheckParameters(const std::map< std::string, double > &DPars)
A method to check if all the mandatory parameters for QCD have been provided in model initialization.
Definition: QCD.cpp:421
static std::string SMvars[NSMvars]
A string array containing the labels of the model parameters in StandardModel.
static const int NSMvars
The number of the model parameters in StandardModel.

◆ checkSMparamsForEWPO()

bool StandardModel::checkSMparamsForEWPO ( )

A method to check whether the parameters relevant to the EWPO are updated.

This function is used for the cashing methods implemented in the current class: DeltaAlphaLepton(), DeltaAlpha(), Mw_SM(), rhoZ_l_SM(), rhoZ_q_SM(), kappaZ_l_SM(), kappaZ_q_SM() and GammaW_SM(). When the values of the StandardModel parameters are updated in the Monte Carlo run and differ from those stored in the cache SMparamsForEWPO_cache, this function updates the cache, and returns false.

Returns
a boolean that is true if the parameters are not updated.
See also
NumSMParamsForEWPO

Definition at line 555 of file StandardModel/src/StandardModel.cpp.

556{
557 // 11 parameters in QCD:
558 // AlsMz, Mz, mup, mdown, mcharm, mstrange, mtop, mbottom,
559 // mut, mub, muc
560 // 19 parameters in StandardModel
561 // GF, ale, dAle5Mz, mHl,
562 // mneutrino_1, mneutrino_2, mneutrino_3, melectron, mmu, mtau,
563 // delMw, delSin2th_l, delSin2th_q, delSin2th_b, delGammaZ, delsigma0H, delR0l, delR0c, delR0b,
564 // 3 flags in StandardModel
565 // FlagMw_cache, FlagRhoZ_cache, FlagKappaZ_cache
566
567 // Note: When modifying the array below, the constant NumSMParams has to
568 // be modified accordingly.
569 double SMparams[NumSMParamsForEWPO] = {
571 mHl, mtpole,
576 leptons[MU].getMass(),
578 quarks[UP].getMass(),
583 mut, mub, muc,
588 };
589
590 // check updated parameters
591 bool bNotUpdated = true;
592 for (int i = 0; i < NumSMParamsForEWPO; ++i) {
593 if (SMparamsForEWPO_cache[i] != SMparams[i]) {
594 SMparamsForEWPO_cache[i] = SMparams[i];
595 bNotUpdated &= false;
596 }
597 }
598
599 return bNotUpdated;
600}
@ UP
Definition: QCD.h:324
@ DOWN
Definition: QCD.h:325
@ STRANGE
Definition: QCD.h:327
double mtpole
The pole mass of the top quark.
Definition: QCD.h:1020
double SMparamsForEWPO_cache[NumSMParamsForEWPO]
double Mw_inp
The mass of the boson in GeV used as input for FlagMWinput = TRUE.
double SchemeToDouble(const std::string scheme) const
A method to convert a given scheme name in string form into a floating-point number with double preci...
static const int NumSMParamsForEWPO
The number of the SM parameters that are relevant to the EW precision observables.

◆ computeBrHto4f()

const double StandardModel::computeBrHto4f ( ) const
inline

The Br \((H\to 4f)\) in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
Br \((H\to 4f)\) in the Standard Model

Definition at line 2946 of file StandardModel.h.

2947 {
2948 return 2.406e-01; // Mh=125.1 GeV
2949 }

◆ computeBrHto4l2()

const double StandardModel::computeBrHto4l2 ( ) const
inline

The Br \((H\to 4l)\) \(l=e,\mu\) in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
Br \((H\to 4l)\) \(l=e,\muu\) in the Standard Model

Definition at line 2913 of file StandardModel.h.

2914 {
2915 return 1.252e-04; // Mh=125.1 GeV
2916 }

◆ computeBrHto4l3()

const double StandardModel::computeBrHto4l3 ( ) const
inline

The Br \((H\to 4l)\) \(l=e,\mu,\tau\) in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
Br \((H\to 4l)\) \(l=e,\mu,\tau\) in the Standard Model

Definition at line 2924 of file StandardModel.h.

2925 {
2926 return 2.771e-04; // Mh=125.1 GeV
2927 }

◆ computeBrHto4q()

const double StandardModel::computeBrHto4q ( ) const
inline

The Br \((H\to 4q)\) in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
Br \((H\to 4q)\) in the Standard Model

Definition at line 2935 of file StandardModel.h.

2936 {
2937 return 1.098e-01; // Mh=125.1 GeV
2938 }

◆ computeBrHto4v()

const double StandardModel::computeBrHto4v ( ) const
inline

The Br \((H\to 4\nu)\) in the Standard Model.

Returns
Br \((H\to 4\nu)\) in the Standard Model

Definition at line 2869 of file StandardModel.h.

2870 {
2871 return 1.06e-3;
2872 }

◆ computeBrHtobb()

const double StandardModel::computeBrHtobb ( ) const
inline

The Br \((H\to bb)\) in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
Br \((H\to bb)\) in the Standard Model

Definition at line 2856 of file StandardModel.h.

2857 {
2858 return 5.807e-1; // Mh=125.1 GeV
2859 //return 5.67e-1; // Mh=125.6 GeV
2860 }

◆ computeBrHtocc()

const double StandardModel::computeBrHtocc ( ) const
inline

The Br \((H\to cc)\) in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
Br \((H\to cc)\) in the Standard Model

Definition at line 2833 of file StandardModel.h.

2834 {
2835 return 2.883e-2; // Mh=125.1 GeV
2836 //return 2.86e-2; // Mh=125.6 GeV
2837 }

◆ computeBrHtoevmuv()

const double StandardModel::computeBrHtoevmuv ( ) const
inline

The Br \((H\to e \nu \mu \nu)\) in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
Br \((H\to e \nu \mu \nu)\) in the Standard Model

Definition at line 2880 of file StandardModel.h.

2881 {
2882 return 2.539e-03; // Mh=125.1 GeV
2883 }

◆ computeBrHtogaga()

const double StandardModel::computeBrHtogaga ( ) const
inline

The Br \((H\to\gamma\gamma)\) in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
Br \((H\to\gamma\gamma)\) in the Standard Model

Definition at line 2799 of file StandardModel.h.

2800 {
2801 return 2.27e-3; // Mh=125.1 GeV
2802 }

◆ computeBrHtogg()

const double StandardModel::computeBrHtogg ( ) const
inline

The Br \((H\to gg)\) in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
Br \((H\to gg)\)

Definition at line 2752 of file StandardModel.h.

2753 {
2754 return 8.179e-2; // Mh=125.1 GeV
2755 }

◆ computeBrHtollvv2()

const double StandardModel::computeBrHtollvv2 ( ) const
inline

The Br \((H\to l^+ l^- \nu \nu)\) \(l=e,\mu\) in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
Br \((H\to l^+ l^- \nu \nu)\) \(l=e,\mu\) in the Standard Model

Definition at line 2891 of file StandardModel.h.

2892 {
2893 return 1.063e-02; // Mh=125.1 GeV
2894 }

◆ computeBrHtollvv3()

const double StandardModel::computeBrHtollvv3 ( ) const
inline

The Br \((H\to l^+ l^- \nu \nu)\) \(l=e,\mu,\tau\) in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
Br \((H\to l^+ l^- \nu \nu)\) \(l=e,\mu,\tau\) in the Standard Model

Definition at line 2902 of file StandardModel.h.

2903 {
2904 return 2.356e-02; // Mh=125.1 GeV
2905 }

◆ computeBrHtomumu()

const double StandardModel::computeBrHtomumu ( ) const
inline

The Br \((H\to \mu\mu)\) in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
Br \((H\to \mu\mu)\) in the Standard Model

Definition at line 2810 of file StandardModel.h.

2811 {
2812 return 2.17e-4; // Mh=125.1 GeV
2813 }

◆ computeBrHtoss()

const double StandardModel::computeBrHtoss ( ) const
inline

The Br \((H\to ss)\) in the Standard Model.

From Table 7 in http://cdsweb.cern.ch/record/2629412/files/ATLAS-CONF-2018-031.pdf

Returns
Br \((H\to ss)\) in the Standard Model

Definition at line 2845 of file StandardModel.h.

2846 {
2847 return 4.0e-4;
2848 }

◆ computeBrHtotautau()

const double StandardModel::computeBrHtotautau ( ) const
inline

The Br \((H\to \tau\tau)\) in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
Br \((H\to \tau\tau)\) in the Standard Model

Definition at line 2821 of file StandardModel.h.

2822 {
2823 return 6.256e-2; // Mh=125.1 GeV
2824 //return 6.22e-2; // Mh=125.6 GeV
2825 }

◆ computeBrHtoWW()

const double StandardModel::computeBrHtoWW ( ) const
inline

The Br \((H\to WW)\) in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
Br \((H\to WW)\) in the Standard Model

Definition at line 2763 of file StandardModel.h.

2764 {
2765 //return 2.23e-1; // Mh=125.5 GeV
2766 return 2.154e-1; // Mh=125.1 GeV
2767 }

◆ computeBrHtoZga()

const double StandardModel::computeBrHtoZga ( ) const
inline

The Br \((H\to Z\gamma)\) in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
Br \((H\to Z\gamma)\) in the Standard Model

Definition at line 2787 of file StandardModel.h.

2788 {
2789 return 1.541e-3; // Mh=125.1 GeV
2790 //return 1.59e-3; // Mh=125.6 GeV
2791 }

◆ computeBrHtoZZ()

const double StandardModel::computeBrHtoZZ ( ) const
inline

The Br \((H\to ZZ)\) in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
Br \((H\to ZZ)\) in the Standard Model

Definition at line 2775 of file StandardModel.h.

2776 {
2777 return 2.643e-2; // Mh=125.1 GeV
2778 //return 2.79e-2; // Mh=125.6 GeV
2779 }

◆ computeCKM()

void StandardModel::computeCKM ( )
protectedvirtual

The method to compute the CKM matrix.

Definition at line 375 of file StandardModel/src/StandardModel.cpp.

376{
377 if (requireCKM) {
378 if (FlagWolfenstein) {
380 Vus = myCKM.getV_us().abs();
381 Vcb = myCKM.getV_cb().abs();
382 Vub = myCKM.getV_ub().abs();
384 } else if (FlagUseVud) {
387 A = myCKM.getA();
388 rhob = myCKM.getRhoBar();
389 etab = myCKM.getEtaBar();
390 Vus = myCKM.getV_us().abs();
391 } else {
394 A = myCKM.getA();
395 rhob = myCKM.getRhoBar();
396 etab = myCKM.getEtaBar();
397 Vud = myCKM.getV_ud().abs();
398 }
399 }
400 myPMNS.computePMNS(s12, s13, s23, delta, alpha21, alpha31); // WARNING: This does not do anything since the input values are not set.
401}
void computeCKMwithWolfenstein(double Lambda_v, double A_v, double Rho_v, double Eta_v)
A set method to calculate the CKM matrix from Wolfenstein parameters.
Definition: CKM.cpp:13
const gslpp::complex getV_ud() const
A member for returning the value of the CKM element .
Definition: CKM.h:202
const gslpp::complex getV_us() const
A member for returning the value of the CKM element .
Definition: CKM.h:211
const double computeGamma() const
The CKM angle .
Definition: CKM.cpp:125
const gslpp::complex getV_cb() const
A member for returning the value of the CKM element .
Definition: CKM.h:247
const gslpp::complex getV_ub() const
A member for returning the value of the CKM element .
Definition: CKM.h:220
const double getA() const
A member for returning the value of the Wolfenstein parameter .
Definition: CKM.h:97
void computeCKM(double Vus_v, double Vcb_v, double Vub_v, double gamma_v, bool useVud=false)
A set method to calculate the CKM matrix from CKM elements and .
Definition: CKM.cpp:86
const double getRhoBar() const
A member for returning the value of the Wolfenstein parameter .
Definition: CKM.h:70
const double getLambda() const
A member for returning the value of the Wolfenstein parameter .
Definition: CKM.h:88
const double getEtaBar() const
A member for returning the value of the Wolfenstein parameter .
Definition: CKM.h:79
void computePMNS(double s12_v, double s13_v, double s23_v, double delta_v, double alpha21_v, double alpha31_v)
A set method to calculate the PMNS matrix from PMNS parameters.
Definition: PMNS.cpp:13
double Vub
used as an input for FlagWolfenstein = FALSE
double gamma
used as an input for FlagWolfenstein = FALSE
double Vud
used as an input for FlagWolfenstein = FALSE and FlagUseVud = TRUE
CKM myCKM
An object of type CKM.
double Vcb
used as an input for FlagWolfenstein = FALSE
double Vus
used as an input for FlagWolfenstein = FALSE

◆ ComputeDeltaR_rem()

void StandardModel::ComputeDeltaR_rem ( const double  Mw_i,
double  DeltaR_rem[orders_EW_size] 
) const

A method to collect \(\Delta r_{\mathrm{rem}}\) computed via subclasses.

This function collects \(\Delta r_{\mathrm{rem}}\) computed via EWSMOneLoopEW, EWSMTwoLoopQCD, EWSMTwoLoopEW, EWSMThreeLoopQCD, EWSMThreeLoopEW2QCD and EWSMThreeLoopEW classes.

Parameters
[in]Mw_ithe \(W\)-boson mass
[out]DeltaR_remArray of \(\Delta r_{\mathrm{rem}}\)

Definition at line 1154 of file StandardModel/src/StandardModel.cpp.

1156{
1157 if (flag_order[EW1])
1158 DeltaR_rem[EW1] = myOneLoopEW->DeltaR_rem(Mw_i);
1159 else
1160 DeltaR_rem[EW1] = 0.0;
1161 if (flag_order[EW1QCD1])
1162 DeltaR_rem[EW1QCD1] = myTwoLoopQCD->DeltaR_rem(Mw_i);
1163 else
1164 DeltaR_rem[EW1QCD1] = 0.0;
1165 if (flag_order[EW1QCD2])
1166 DeltaR_rem[EW1QCD2] = myThreeLoopQCD->DeltaR_rem(Mw_i);
1167 else
1168 DeltaR_rem[EW1QCD2] = 0.0;
1169 if (flag_order[EW2])
1170 DeltaR_rem[EW2] = myTwoLoopEW->DeltaR_rem(Mw_i);
1171 else
1172 DeltaR_rem[EW2] = 0.0;
1173 if (flag_order[EW2QCD1])
1174 DeltaR_rem[EW2QCD1] = myThreeLoopEW2QCD->DeltaR_rem(Mw_i);
1175 else
1176 DeltaR_rem[EW2QCD1] = 0.0;
1177 if (flag_order[EW3])
1178 DeltaR_rem[EW3] = myThreeLoopEW->DeltaR_rem(Mw_i);
1179 else
1180 DeltaR_rem[EW3] = 0.0;
1181}
double DeltaR_rem(const double Mw_i) const
Remainder contribution of to , denoted as .
double DeltaR_rem(const double Mw_i) const
Remainder contribution of to , denoted as .
double DeltaR_rem(const double Mw_i) const
Remainder contribution of to , denoted as .
double DeltaR_rem(const double Mw_i) const
Remainder contribution of to , denoted as .
double DeltaR_rem(const double Mw_i) const
Remainder contribution of to , denoted as .
double DeltaR_rem(const double Mw_i) const
Remainder contribution of to , denoted as .

◆ ComputeDeltaRho()

void StandardModel::ComputeDeltaRho ( const double  Mw_i,
double  DeltaRho[orders_EW_size] 
) const

A method to collect \(\Delta\rho\) computed via subclasses.

This function collects \(\Delta\rho\) computed via EWSMOneLoopEW, EWSMTwoLoopQCD, EWSMTwoLoopEW, EWSMThreeLoopQCD, EWSMThreeLoopEW2QCD and EWSMThreeLoopEW classes.

Parameters
[in]Mw_ithe \(W\)-boson mass
[out]DeltaRhoArray of \(\Delta\rho\)

Definition at line 1125 of file StandardModel/src/StandardModel.cpp.

1127{
1128 if (flag_order[EW1])
1129 DeltaRho[EW1] = myOneLoopEW->DeltaRho(Mw_i);
1130 else
1131 DeltaRho[EW1] = 0.0;
1132 if (flag_order[EW1QCD1])
1133 DeltaRho[EW1QCD1] = myTwoLoopQCD->DeltaRho(Mw_i);
1134 else
1135 DeltaRho[EW1QCD1] = 0.0;
1136 if (flag_order[EW1QCD2])
1137 DeltaRho[EW1QCD2] = myThreeLoopQCD->DeltaRho(Mw_i);
1138 else
1139 DeltaRho[EW1QCD2] = 0.0;
1140 if (flag_order[EW2])
1141 DeltaRho[EW2] = myTwoLoopEW->DeltaRho(Mw_i);
1142 else
1143 DeltaRho[EW2] = 0.0;
1144 if (flag_order[EW2QCD1])
1145 DeltaRho[EW2QCD1] = myThreeLoopEW2QCD->DeltaRho(Mw_i);
1146 else
1147 DeltaRho[EW2QCD1] = 0.0;
1148 if (flag_order[EW3])
1149 DeltaRho[EW3] = myThreeLoopEW->DeltaRho(Mw_i);
1150 else
1151 DeltaRho[EW3] = 0.0;
1152}
double DeltaRho(const double Mw_i) const
Leading one-loop contribution of to , denoted as .
double DeltaRho(const double Mw_i) const
Leading three-loop contribution of to , denoted as .
double DeltaRho(const double Mw_i) const
Leading three-loop contribution of to , denoted as .
double DeltaRho(const double Mw_i) const
Leading three-loop QCD contribution of to , denoted as .
double DeltaRho(const double Mw_i) const
Leading two-loop contribution of to , denoted as .
double DeltaRho(const double Mw_i) const
Leading two-loop QCD contribution of to , denoted as .

◆ computeGammaHgaga_tt()

const double StandardModel::computeGammaHgaga_tt ( ) const
inline

The top loop contribution to \(H\to\gamma\gamma\) in the Standard Model.

Currently it returns the value of tab 40 in ref. [Heinemeyer:2013tqa]

Returns
Width of \(H\to\gamma\gamma\) (top loop contribution squared) in eV

Definition at line 3034 of file StandardModel.h.

3035 {
3036 return 662.84; // in eV for Mh=125 GeV
3037 //return 680.39; // in eV for Mh=126 GeV
3038 }

◆ computeGammaHgaga_tW()

const double StandardModel::computeGammaHgaga_tW ( ) const
inline

The mixed \(t-W\) loop contribution to \(H\to\gamma\gamma\) in the Standard Model.

Currently it returns the value of tab 40 in ref. [Heinemeyer:2013tqa]

Returns
Width of \(H\to\gamma\gamma\) (top W loop interference) in eV

Definition at line 3056 of file StandardModel.h.

3057 {
3058 return -6249.93; // in eV for Mh=125 GeV
3059 //return -6436.35; // in eV for Mh=126 GeV
3060 }

◆ computeGammaHgaga_WW()

const double StandardModel::computeGammaHgaga_WW ( ) const
inline

The \(W\) loop contribution to \(H\to\gamma\gamma\) in the Standard Model.

Currently it returns the value of tab 40 in ref. [Heinemeyer:2013tqa]

Returns
Width of \(H\to\gamma\gamma\) (W loop contribution squared) in eV

Definition at line 3045 of file StandardModel.h.

3046 {
3047 return 14731.86; // in eV for Mh=125 GeV
3048 //return 15221.98; // in eV for Mh=126 GeV
3049 }

◆ computeGammaHgg_bb()

const double StandardModel::computeGammaHgg_bb ( ) const
inline

The bottom loop contribution to \(H\to gg\) in the Standard Model.

Currently it returns the value of tab 39 in ref. [Heinemeyer:2013tqa]

Returns
Width of \(H\to gg\) (bottom loop contribution squared) in keV

Definition at line 2979 of file StandardModel.h.

2980 {
2981 return 3.96; // in keV for Mh=125 GeV
2982 //return 3.95; // in keV for Mh=126 GeV
2983 }

◆ computeGammaHgg_tb()

const double StandardModel::computeGammaHgg_tb ( ) const
inline

The top-bottom interference contribution to \(H\to gg\) in the Standard Model.

Currently it returns the value of tab 39 in ref. [Heinemeyer:2013tqa]

Returns
Width of \(H\to gg\) (top-bottom interference contribution) in keV

Definition at line 2990 of file StandardModel.h.

2991 {
2992 return -42.1; // in keV for Mh=125 GeV
2993 //return -42.7; // in keV for Mh=126 GeV
2994 }

◆ computeGammaHgg_tt()

const double StandardModel::computeGammaHgg_tt ( ) const
inline

The top loop contribution to \(H\to gg\) in the Standard Model.

Currently it returns the value of tab 39 in ref. [Heinemeyer:2013tqa]

Returns
Width of \(H\to gg\) (top loop contribution squared) in keV

Definition at line 2968 of file StandardModel.h.

2969 {
2970 return 380.8; // in keV for Mh=125 GeV
2971 //return 389.6; // in keV for Mh=126 GeV
2972 }

◆ computeGammaHTotal()

const double StandardModel::computeGammaHTotal ( ) const
inline

The Higgs total width in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
\(\Gamma_h\) in GeV in the Standard Model

Definition at line 2957 of file StandardModel.h.

2958 {
2959 return 4.101e-3; // Mh=125.1 GeV
2960 //return 4.15e-3; // Mh=125.6 GeV
2961 }

◆ computeGammaHZga_tt()

const double StandardModel::computeGammaHZga_tt ( ) const
inline

The top loop contribution to \(H\to Z\gamma\) in the Standard Model.

Currently it returns the value of tab 41 in ref. [Heinemeyer:2013tqa]

Returns
Width of \(H\to Z\gamma\) (top loop contribution squared) in eV

Definition at line 3001 of file StandardModel.h.

3002 {
3003 return 21.74; // in eV for Mh=125 GeV
3004 //return 23.51; // in eV for Mh=126 GeV
3005 }

◆ computeGammaHZga_tW()

const double StandardModel::computeGammaHZga_tW ( ) const
inline

The mixed \(t-W\) loop contribution to \(H\to Z\gamma\) in the Standard Model.

Currently it returns the value of tab 41 in ref. [Heinemeyer:2013tqa]

Returns
Width of \(H\to Z\gamma\) (top W loop interference) in eV

Definition at line 3023 of file StandardModel.h.

3024 {
3025 return -780.4; // in eV for Mh=125 GeV
3026 //return -848.1; // in eV for Mh=126 GeV
3027 }

◆ computeGammaHZga_WW()

const double StandardModel::computeGammaHZga_WW ( ) const
inline

The \(W\) loop contribution to \(H\to Z\gamma\) in the Standard Model. Currently it returns the value of tab 41 in ref. [Heinemeyer:2013tqa].

Returns
Width of \(H\to Z\gamma\) (W loop contribution squared) in eV

Definition at line 3012 of file StandardModel.h.

3013 {
3014 return 7005.6; // in eV for Mh=125 GeV
3015 //return 7648.4; // in eV for Mh=126 GeV
3016 }

◆ computeSigmabbH()

const double StandardModel::computeSigmabbH ( const double  sqrt_s) const
inline

The bbH production cross section in the Standard Model.

Definition at line 2735 of file StandardModel.h.

2736 {
2737 if (sqrt_s == 13.0){
2738 return 0.4863; // in pb for Mh=125.09 GeV
2739 }
2740 else if (sqrt_s == 13.6) {
2741 return 0.566; // in pb for Mh=125.09 GeV (NLO+NNLLpart+ybyt matching)
2742 } else
2743 throw std::runtime_error("Bad argument in StandardModel::computeSigmabbH()");
2744 }

◆ computeSigmaggH()

const double StandardModel::computeSigmaggH ( const double  sqrt_s) const
inline

The ggH cross section in the Standard Model.

See Tables B.67 and B.74 in ref. [Heinemeyer:2013tqa] and the updates in https://twiki.cern.ch/twiki/bin/view/LHCPhysics/LHCHXSWG2KAPPA for 7 and 8 TeV For the 13, 14 and 27 TeV values we use the updated numbers wrt the CERN Report 4 2016 from https://twiki.cern.ch/twiki/bin/view/LHCPhysics/LHCHXSWG1HELHCXsecs https://twiki.cern.ch/twiki/pub/LHCPhysics/LHCHXSWG1HELHCXsecs/hlhehiggs.pdf For 13.6 TeV we follow the LHC Higgs WG note: arXiv: 2402.09955 [hep-ph] V1: https://arxiv.org/pdf/2402.09955v1.pdf For the 100 TeV values we use the values from https://twiki.cern.ch/twiki/bin/view/LHCPhysics/HiggsEuropeanStrategy

Parameters
[in]sqrt_sthe center-of-mass energy in TeV
Returns
ggH cross section in pb

Definition at line 2371 of file StandardModel.h.

2372 {
2373 if (sqrt_s == 7.0) {
2374 return 16.83; // in pb for Mh=125.1 GeV
2375 } else if (sqrt_s == 8.0) {
2376 return 21.40; // in pb for Mh=125.1 GeV
2377 } else if (sqrt_s == 13.0) {
2378 return 48.61; // in pb for Mh=125.09 GeV
2379 } else if (sqrt_s == 13.6) {
2380 return 52.17; // in pb for Mh=125.09 GeV
2381 } else if (sqrt_s == 14.0) {
2382 return 54.72; // in pb for Mh=125.09 GeV
2383 } else if (sqrt_s == 27.0) {
2384 return 146.65; // in pb for Mh=125.09 GeV
2385 } else if (sqrt_s == 100.0) {
2386 return 740.3; // in pb for Mh=125. GeV
2387 } else if (sqrt_s == 1.96) {
2388 return 0.9493; // in pb for Mh=125 GeV
2389 } else
2390 throw std::runtime_error("Bad argument in StandardModel::computeSigmaggH()");
2391 }

◆ computeSigmaggH_bb()

const double StandardModel::computeSigmaggH_bb ( const double  sqrt_s) const
inline

The square of the bottom-quark contribution to the ggH cross section in the Standard Model.

The values have been obtained from: https://twiki.cern.ch/twiki/bin/view/LHCPhysics/LHCHXSWG2KAPPA For 13.6 TeV we follow what is done in some cases in the LHC Higgs WG note: arXiv: 2402.09955 [hep-ph] V1 and use linear interpolation between the values at 13 and 14 TeV

Parameters
[in]sqrt_sthe center-of-mass energy in TeV
Returns
\(\sigma_{ggH}^{bb}\) in pb

Definition at line 2433 of file StandardModel.h.

2434 {
2435 if (sqrt_s == 7.0) {
2436 return 0.04; // in pb for Mh=125.09 GeV
2437 } else if (sqrt_s == 8.0) {
2438 return 0.05; // in pb for Mh=125.09 GeV
2439 } else if (sqrt_s == 13.0) {
2440 return 0.10; // in pb for Mh=125.09 GeV
2441 } else if (sqrt_s == 13.6) {
2442 return 0.106; // in pb for Mh=125.09 GeV (interpolation between 13 and 14 TeV)
2443 } else if (sqrt_s == 14.0) {
2444 return 0.11; // in pb for Mh=125.09 GeV
2445 } else if (sqrt_s == 27.0) {
2446 return computeSigmaggH(sqrt_s) / computeSigmaggH(14.) * computeSigmaggH_bb(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2447 } else if (sqrt_s == 100.0) {
2448 return computeSigmaggH(sqrt_s) / computeSigmaggH(14.) * computeSigmaggH_bb(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2449 } else
2450 throw std::runtime_error("Bad argument in StandardModel::computeSigmaggH_bb()");
2451 }
const double computeSigmaggH(const double sqrt_s) const
The ggH cross section in the Standard Model.
const double computeSigmaggH_bb(const double sqrt_s) const
The square of the bottom-quark contribution to the ggH cross section in the Standard Model.

◆ computeSigmaggH_tb()

const double StandardModel::computeSigmaggH_tb ( const double  sqrt_s) const
inline

The top-bottom interference contribution to the ggH cross section in the Standard Model.

The values have been obtained from: https://twiki.cern.ch/twiki/bin/view/LHCPhysics/LHCHXSWG2KAPPA For 13.6 TeV we follow what is done in some cases in the LHC Higgs WG note: arXiv: 2402.09955 [hep-ph] V1 and use linear interpolation between the values at 13 and 14 TeV

Parameters
[in]sqrt_sthe center-of-mass energy in TeV
Returns
\(\sigma_{ggH}^{tb}\) in pb

Definition at line 2463 of file StandardModel.h.

2464 {
2465 if (sqrt_s == 7.0) {
2466 return -0.66; // in pb for Mh=125.09 GeV
2467 } else if (sqrt_s == 8.0) {
2468 return -0.82; // in pb for Mh=125.09 GeV
2469 } else if (sqrt_s == 13.0) {
2470 return -1.73; // in pb for Mh=125.09 GeV
2471 } else if (sqrt_s == 13.6) {
2472 return -1.844; // in pb for Mh=125.09 GeV (interpolation between 13 and 14 TeV)
2473 } else if (sqrt_s == 14.0) {
2474 return -1.92; // in pb for Mh=125.09 GeV
2475 } else if (sqrt_s == 27.0) {
2476 return computeSigmaggH(sqrt_s) / computeSigmaggH(14.) * computeSigmaggH_tb(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2477 } else if (sqrt_s == 100.0) {
2478 return computeSigmaggH(sqrt_s) / computeSigmaggH(14.) * computeSigmaggH_tb(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2479 } else
2480 throw std::runtime_error("Bad argument in StandardModel::computeSigmaggH_tb()");
2481 }
const double computeSigmaggH_tb(const double sqrt_s) const
The top-bottom interference contribution to the ggH cross section in the Standard Model.

◆ computeSigmaggH_tt()

const double StandardModel::computeSigmaggH_tt ( const double  sqrt_s) const
inline

The square of the top-quark contribution to the ggH cross section in the Standard Model.

The values have been obtained from: https://twiki.cern.ch/twiki/bin/view/LHCPhysics/LHCHXSWG2KAPPA For 13.6 TeV we follow what is done in some cases in the LHC Higgs WG note: arXiv: 2402.09955 [hep-ph] V1 and use linear interpolation between the values at 13 and 14 TeV

Parameters
[in]sqrt_sthe center-of-mass energy in TeV
Returns
\(\sigma_{ggH}^{tt}\) in pb

Definition at line 2403 of file StandardModel.h.

2404 {
2405 if (sqrt_s == 7.0) {
2406 return 16.69; // in pb for Mh=125.09 GeV
2407 } else if (sqrt_s == 8.0) {
2408 return 21.20; // in pb for Mh=125.09 GeV
2409 } else if (sqrt_s == 13.0) {
2410 return 47.94; // in pb for Mh=125.09 GeV
2411 } else if (sqrt_s == 13.6) {
2412 return 51.534; // in pb for Mh=125.09 GeV (interpolation between 13 and 14 TeV)
2413 } else if (sqrt_s == 14.0) {
2414 return 53.93; // in pb for Mh=125.09 GeV
2415 } else if (sqrt_s == 27.0) {
2416 return computeSigmaggH(sqrt_s) / computeSigmaggH(14.) * computeSigmaggH_tt(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2417 } else if (sqrt_s == 100.0) {
2418 return computeSigmaggH(sqrt_s) / computeSigmaggH(14.) * computeSigmaggH_tt(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2419 } else
2420 throw std::runtime_error("Bad argument in StandardModel::computeSigmaggH_tt()");
2421 }
const double computeSigmaggH_tt(const double sqrt_s) const
The square of the top-quark contribution to the ggH cross section in the Standard Model.

◆ computeSigmatHq()

const double StandardModel::computeSigmatHq ( const double  sqrt_s) const
inline

The tHq production cross section in the Standard Model.

For the 13 TeV values we use the official numbers a la CERN Report 4 2016 from https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageAt13TeV

Definition at line 2716 of file StandardModel.h.

2717 {
2718 if (sqrt_s == 13.0) {
2719 return 0.07426; // in pb for Mh=125.09 GeV
2720 } else
2721 throw std::runtime_error("Bad argument in StandardModel::computeSigmatHq()");
2722 }

◆ computeSigmattH()

const double StandardModel::computeSigmattH ( const double  sqrt_s) const
inline

The ttH production cross section in the Standard Model.

See Tables B.67 and B.74 in ref. [Heinemeyer:2013tqa] . For the 13 TeV values we use the official numbers a la CERN Report 4 2016 from https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageAt13TeV https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageAt14TeV For the 14 and 27 TeV values we use the updated numbers wrt the CERN Report 4 2016 from https://twiki.cern.ch/twiki/bin/view/LHCPhysics/LHCHXSWG1HELHCXsecs https://twiki.cern.ch/twiki/pub/LHCPhysics/LHCHXSWG1HELHCXsecs/hlhehiggs.pdf For 13.6 TeV we follow the LHC Higgs WG note: arXiv: 2402.09955 [hep-ph] V1: https://arxiv.org/pdf/2402.09955v1.pdf For the 100 TeV values we use the values from https://twiki.cern.ch/twiki/bin/view/LHCPhysics/HiggsEuropeanStrategy

Parameters
[in]sqrt_sthe center-of-mass energy in TeV
Returns
ttH production cross section in pb

Definition at line 2686 of file StandardModel.h.

2687 {
2688 if (sqrt_s == 7.0) {
2689 return 0.0861; // in pb for Mh=125.1 GeV
2690 //return 0.0851; // in pb for Mh=125.6 GeV
2691 } else if (sqrt_s == 8.0) {
2692 return 0.129; // in pb for Mh=125.1 GeV
2693 //return 0.1274; // in pb for Mh=125.6 GeV
2694 } else if (sqrt_s == 13.0) {
2695 return 0.5060; // in pb for Mh=125.1 GeV
2696 } else if (sqrt_s == 13.6) {
2697 return 0.5688; // in pb for Mh=125.09 GeV
2698 } else if (sqrt_s == 14.0) {
2699 return 0.6128; // in pb for Mh=125.09 GeV
2700 } else if (sqrt_s == 27.0) {
2701 return 2.86; // in pb for Mh=125.09 GeV
2702 } else if (sqrt_s == 100.0) {
2703 return 37.9; // in pb for Mh=125. GeV
2704 } else if (sqrt_s == 1.96) {
2705 return 0.0043; // in pb for Mh=125 GeV
2706 } else
2707 throw std::runtime_error("Bad argument in StandardModel::computeSigmattH()");
2708 }

◆ computeSigmaVBF()

const double StandardModel::computeSigmaVBF ( const double  sqrt_s) const
inline

The VBF cross section in the Standard Model.

See Tables B.67 and B.74 in ref. [Heinemeyer:2013tqa] . For the 7, 8, 13, 14 and 27 TeV values we use the updated numbers wrt the CERN Report 4 2016 from https://twiki.cern.ch/twiki/bin/view/LHCPhysics/LHCHXSWG1HELHCXsecs https://twiki.cern.ch/twiki/pub/LHCPhysics/LHCHXSWG1HELHCXsecs/hlhehiggs.pdf For 13.6 TeV we follow the LHC Higgs WG note: arXiv: 2402.09955 [hep-ph] V1: https://arxiv.org/pdf/2402.09955v1.pdf For the 100 TeV values we use the values from https://twiki.cern.ch/twiki/bin/view/LHCPhysics/HiggsEuropeanStrategy

Parameters
[in]sqrt_sthe center-of-mass energy in TeV
Returns
VBF cross section in pb

Definition at line 2496 of file StandardModel.h.

2497 {
2498 if (sqrt_s == 7.0) {
2499 return 1.241; // in pb for Mh=125.09 GeV
2500 } else if (sqrt_s == 8.0) {
2501 return 1.601; // in pb for Mh=125.09 GeV
2502 } else if (sqrt_s == 13.0) {
2503 return 3.766; // in pb for Mh=125.09 GeV
2504 } else if (sqrt_s == 13.6) {
2505 return 4.075; // in pb for Mh=125.09 GeV
2506 } else if (sqrt_s == 14.0) {
2507 return 4.260; // in pb for Mh=125.09 GeV
2508 } else if (sqrt_s == 27.0) {
2509 return 11.838; // in pb for Mh=125.09 GeV
2510 } else if (sqrt_s == 100.0) {
2511 return 82.0; // in pb for Mh=125. GeV
2512 } else if (sqrt_s == 1.96) {
2513 return 0.0653; // in pb for Mh=125 GeV
2514 } else
2515 throw std::runtime_error("Bad argument in StandardModel::computeSigmaVBF()");
2516 }

◆ computeSigmaWF()

const double StandardModel::computeSigmaWF ( const double  sqrt_s) const
inline

The W fusion contribution \(\sigma_{WF}\) to higgs-production cross section in the Standard Model.

The values have been obtained from: https://twiki.cern.ch/twiki/bin/view/LHCPhysics/LHCHXSWG2KAPPA For 13.6 TeV we follow what is done in some cases in the LHC Higgs WG note: arXiv: 2402.09955 [hep-ph] V1 and use linear interpolation between the values at 13 and 14 TeV

Parameters
[in]sqrt_sthe center-of-mass energy in TeV
Returns
W fusion contribution \(\sigma_{WF}\) to cross section in pb

Definition at line 2529 of file StandardModel.h.

2530 {
2531 if (sqrt_s == 7.0) {
2532 return 0.946; // in pb for Mh=125 GeV
2533 } else if (sqrt_s == 8.0) {
2534 return 1.220; // in pb for Mh=125 GeV
2535 } else if (sqrt_s == 13.0) {
2536 return 2.882; // in pb for Mh=125 GeV
2537 } else if (sqrt_s == 13.6) {
2538 return 3.1088; // in pb for Mh=125 GeV (interpolation between 13 and 14 TeV)
2539 } else if (sqrt_s == 14.0) {
2540 return 3.260; // in pb for Mh=125 GeV
2541 } else if (sqrt_s == 27.0) {
2542 return computeSigmaVBF(sqrt_s) / computeSigmaVBF(14.) * computeSigmaWF(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2543 } else if (sqrt_s == 100.0) {
2544 return computeSigmaVBF(sqrt_s) / computeSigmaVBF(14.) * computeSigmaWF(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2545 } else if (sqrt_s == 1.96) {
2546 return computeSigmaVBF(sqrt_s) / computeSigmaVBF(7.) * computeSigmaWF(7.); // in the absence of individual cross sections for TeVatron we rescale the LHC ones
2547 } else
2548 throw std::runtime_error("Bad argument in StandardModel::computeSigmaWF()");
2549 }
const double computeSigmaVBF(const double sqrt_s) const
The VBF cross section in the Standard Model.
const double computeSigmaWF(const double sqrt_s) const
The W fusion contribution to higgs-production cross section in the Standard Model.

◆ computeSigmaWH()

const double StandardModel::computeSigmaWH ( const double  sqrt_s) const
inline

The WH production cross section in the Standard Model.

See Tables B.67 and B.74 in ref. [Heinemeyer:2013tqa] . For the 13, 14 and 27 TeV values we use the updated numbers wrt the CERN Report 4 2016 from https://twiki.cern.ch/twiki/bin/view/LHCPhysics/LHCHXSWG1HELHCXsecs https://twiki.cern.ch/twiki/pub/LHCPhysics/LHCHXSWG1HELHCXsecs/hlhehiggs.pdf For 13.6 TeV we follow the LHC Higgs WG note: arXiv: 2402.09955 [hep-ph] V1: https://arxiv.org/pdf/2402.09955v1.pdf For the 100 TeV values we use the values from https://twiki.cern.ch/twiki/bin/view/LHCPhysics/HiggsEuropeanStrategy

Parameters
[in]sqrt_sthe center-of-mass energy in TeV
Returns
WH production cross section in pb

Definition at line 2609 of file StandardModel.h.

2610 {
2611 if (sqrt_s == 7.0) {
2612 return 0.577; // in pb for Mh=125.1 GeV
2613 //return 0.5688; // in pb for Mh=125.6 GeV
2614 } else if (sqrt_s == 8.0) {
2615 return 0.7027; // in pb for Mh=125.1 GeV
2616 //return 0.6931; // in pb for Mh=125.6 GeV
2617 } else if (sqrt_s == 13.0) {
2618 return 1.358; // in pb for Mh=125.09 GeV
2619 } else if (sqrt_s == 13.6) {
2620 return 1.453; // in pb for Mh=125.09 GeV
2621 } else if (sqrt_s == 14.0) {
2622 return 1.498; // in pb for Mh=125.09 GeV
2623 } else if (sqrt_s == 27.0) {
2624 return 3.397; // in pb for Mh=125.09 GeV
2625 } else if (sqrt_s == 100.0) {
2626 return 15.9; // in pb for Mh=125. GeV
2627 } else if (sqrt_s == 1.96) {
2628 return 0.1295; // in pb for Mh=125 GeV
2629 } else
2630 throw std::runtime_error("Bad argument in StandardModel::computeSigmaWH()");
2631 }

◆ computeSigmaZF()

const double StandardModel::computeSigmaZF ( const double  sqrt_s) const
inline

The Z fusion contribution \(\sigma_{ZF}\) to higgs-production cross section in the Standard Model.

The values have been obtained from: https://twiki.cern.ch/twiki/bin/view/LHCPhysics/LHCHXSWG2KAPPA For 13.6 TeV we follow what is done in some cases in the LHC Higgs WG note: arXiv: 2402.09955 [hep-ph] V1 and use linear interpolation between the values at 13 and 14 TeV

Parameters
[in]sqrt_sthe center-of-mass energy in TeV
Returns
W fusion contribution \(\sigma_{ZF}\) to cross section in pb

Definition at line 2562 of file StandardModel.h.

2563 {
2564 if (sqrt_s == 7.0) {
2565 return 0.333; // in pb for Mh=125 GeV
2566 } else if (sqrt_s == 8.0) {
2567 return 0.432; // in pb for Mh=125 GeV
2568 } else if (sqrt_s == 13.0) {
2569 return 1.049; // in pb for Mh=125 GeV
2570 } else if (sqrt_s == 13.6) {
2571 return 1.1342; // in pb for Mh=125 GeV (interpolation between 13 and 14 TeV)
2572 } else if (sqrt_s == 14.0) {
2573 return 1.191; // in pb for Mh=125 GeV
2574 } else if (sqrt_s == 27.0) {
2575 return computeSigmaVBF(sqrt_s) / computeSigmaVBF(14.) * computeSigmaZF(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2576 } else if (sqrt_s == 100.0) {
2577 return computeSigmaVBF(sqrt_s) / computeSigmaVBF(14.) * computeSigmaZF(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2578 } else if (sqrt_s == 1.96) {
2579 return computeSigmaVBF(sqrt_s) / computeSigmaVBF(7.) * computeSigmaZF(7.); // in the absence of individual cross sections for TeVatron we rescale the LHC ones
2580 } else
2581 throw std::runtime_error("Bad argument in StandardModel::computeSigmaZF()");
2582 }
const double computeSigmaZF(const double sqrt_s) const
The Z fusion contribution to higgs-production cross section in the Standard Model.

◆ computeSigmaZH()

const double StandardModel::computeSigmaZH ( const double  sqrt_s) const
inline

The ZH production cross section in the Standard Model.

See Tables B.67 and B.74 in ref. [Heinemeyer:2013tqa] . For the 13, 14 and 27 TeV values we use the updated numbers wrt the CERN Report 4 2016 from https://twiki.cern.ch/twiki/bin/view/LHCPhysics/LHCHXSWG1HELHCXsecs https://twiki.cern.ch/twiki/pub/LHCPhysics/LHCHXSWG1HELHCXsecs/hlhehiggs.pdf For 13.6 TeV we follow the LHC Higgs WG note: arXiv: 2402.09955 [hep-ph] V1: https://arxiv.org/pdf/2402.09955v1.pdf For the 100 TeV values we use the values from https://twiki.cern.ch/twiki/bin/view/LHCPhysics/HiggsEuropeanStrategy

Parameters
[in]sqrt_sthe center-of-mass energy in TeV
Returns
ZH production cross section in pb

Definition at line 2646 of file StandardModel.h.

2647 {
2648 if (sqrt_s == 7.0) {
2649 return 0.3341; // in pb for Mh=125.1 GeV
2650 //return 0.3299; // in pb for Mh=125.6 GeV
2651 } else if (sqrt_s == 8.0) {
2652 return 0.4142; // in pb for Mh=125.1 GeV
2653 //return 0.4091; // in pb for Mh=125.6 GeV
2654 } else if (sqrt_s == 13.0) {
2655 return 0.880; // in pb for Mh=125.09 GeV
2656 } else if (sqrt_s == 13.6) {
2657 return 0.9422; // in pb for Mh=125.09 GeV
2658 } else if (sqrt_s == 14.0) {
2659 return 0.981; // in pb for Mh=125.09 GeV
2660 } else if (sqrt_s == 27.0) {
2661 return 2.463; // in pb for Mh=125.09 GeV
2662 } else if (sqrt_s == 100.0) {
2663 return 11.26; // in pb for Mh=125. GeV
2664 } else if (sqrt_s == 1.96) {
2665 return 0.0785; // in pb for Mh=125 GeV
2666 } else
2667 throw std::runtime_error("Bad argument in StandardModel::computeSigmaZH()");
2668 }

◆ computeSigmaZWF()

const double StandardModel::computeSigmaZWF ( const double  sqrt_s) const
inline

The Z W interference fusion contribution \(\sigma_{ZWF}\) to higgs-production cross section in the Standard Model.

Negligible (0.1%) in the Standard model.

Parameters
[in]sqrt_sthe center-of-mass energy in TeV
Returns
Z W interference fusion contribution \(\sigma_{ZWF}\) to cross section in pb

Definition at line 2591 of file StandardModel.h.

2592 {
2593 return 0.;
2594 }

◆ computeYukawas()

void StandardModel::computeYukawas ( )
protectedvirtual

The method to compute the Yukawas matrix.

Reimplemented in SUSY.

Definition at line 409 of file StandardModel/src/StandardModel.cpp.

410{
411 if (requireYu || requireCKM) {
412 Yu.reset();
413 for (int i = 0; i < 3; i++) {
414 Yu.assign(i, i, this->getmq(quark(UP + 2 * i), v()/ sqrt(2.))/ v() * sqrt(2.));
415// std::cout << quarks[UP + 2 * i].getName() << " mass at EW scale is " << this->getmq(quark(UP + 2 * i), v() / sqrt(2.)) << std::endl;
416 }
417// std::cout << "(top MSbar mass is " << this->Mp2Mbar(this->getMtpole()) << ")" << std::endl;
418 Yu = Yu * myCKM.getCKM();
419 }
420 if (requireYd) {
421 Yd.reset();
422 for (int i = 0; i < 3; i++) {
423 Yd.assign(i, i, this->getmq(quark(DOWN + 2 * i), v() / sqrt(2.)) / v() * sqrt(2.));
424// std::cout << quarks[DOWN + 2 * i].getName() << " mass at " << v() / sqrt(2) << " is " << this->getmq(quark(DOWN + 2 * i), v() / sqrt(2.)) << std::endl;
425 }
426 }
427 if (requireYe) {
428 Ye = gslpp::matrix<gslpp::complex>::Id(3);
429 for (int i = 0; i < 3; i++)
430 Ye.assign(i, i, this->leptons[ELECTRON + 2 * i].getMass() / v() * sqrt(2.));
431 }
432 if (requireYn) {
433 Yn = gslpp::matrix<gslpp::complex>::Id(3);
434 for (int i = 0; i < 3; i++)
435 Yn.assign(i, i, this->leptons[NEUTRINO_1 + 2 * i].getMass() / v() * sqrt(2.));
436 Yn = Yn * myPMNS.getPMNS().hconjugate();
437 }
438}
const gslpp::matrix< gslpp::complex > getCKM() const
A member for returning the CKM matrix.
Definition: CKM.h:59
gslpp::matrix< gslpp::complex > getPMNS() const
A member for returning the PMNS matrix.
Definition: PMNS.h:42
bool requireYu
Switch for generating the Yukawa couplings to the up-type quarks.
Definition: QCD.h:1012
quark
An enum type for quarks.
Definition: QCD.h:323
bool requireYd
Switch for generating the Yukawa couplings to the down-type quarks.
Definition: QCD.h:1013
virtual const double getmq(const QCD::quark q, const double mu) const
The MSbar running quark mass computed at NLO.

◆ cW2() [1/2]

const double StandardModel::cW2 ( ) const
virtual

Definition at line 1080 of file StandardModel/src/StandardModel.cpp.

1081{
1082 return ( cW2(Mw()));
1083// return (1.0 - 0.2312); // FOR HEFFDF1 TEST
1084}

◆ cW2() [2/2]

const double StandardModel::cW2 ( const double  Mw_i) const
virtual

The square of the cosine of the weak mixing angle in the on-shell scheme, denoted as \(c_W^2\).

\[ c_W^2=\cos^2{\theta_W}=\frac{M_W^2}{M_Z^2}. \]

Returns
\(c_W^2\)

Definition at line 1075 of file StandardModel/src/StandardModel.cpp.

1076{
1077 return ( Mw_i * Mw_i / Mz / Mz);
1078}

◆ Dalpha5hMz()

const double StandardModel::Dalpha5hMz ( ) const
virtual

The 5-quark contribution to the running of the em constant to the \(Z\) pole. \(\Delta\alpha_{had}^{(5)}(M_Z)\).

Depending on the flag MWinput this is given by the input parameter dAle5Mz (MWinput=false) or it is computed from Mw (MWinput=true)

Returns
\(\Delta\alpha_{had}^{(5)}(M_Z)\)

Definition at line 1067 of file StandardModel/src/StandardModel.cpp.

1068{
1069 if (FlagMWinput){
1071 } else
1072 return dAle5Mz;
1073}
double dAlpha5hMw() const
The value of obtained from the -boson mass, using the full two-loop EW corrections.

◆ Delta_EWQCD()

double StandardModel::Delta_EWQCD ( const QCD::quark  q) const
protected

The non-factorizable EW-QCD corrections to the partial widths for \(Z\to q\bar{q}\), denoted as \(\Delta_{\mathrm{EW/QCD}}\).

See [Czarnecki:1996ei] and [Harlander:1997zb].

Parameters
[in]qname of a quark (see QCD::quark)
Returns
\(\Delta_{\mathrm{EW/QCD}}\) in GeV

Definition at line 2132 of file StandardModel/src/StandardModel.cpp.

2133{
2134 switch (q) {
2135 case QCD::UP:
2136 case QCD::CHARM:
2137 return ( -0.000113);
2138 case QCD::TOP:
2139 return ( 0.0);
2140 case QCD::DOWN:
2141 case QCD::STRANGE:
2142 return ( -0.000160);
2143 case QCD::BOTTOM:
2144 return ( -0.000040);
2145 default:
2146 throw std::runtime_error("Error in StandardModel::Delta_EWQCD");
2147 }
2148}
@ TOP
Definition: QCD.h:328

◆ DeltaAlpha()

const double StandardModel::DeltaAlpha ( ) const

The total corrections to the electromagnetic coupling \(\alpha\) at the \(Z\)-mass scale, denoted as \(\Delta\alpha(M_Z^2)\).

\[ \Delta\alpha(M_Z^2) = \Delta\alpha_{\rm lept}(M_Z^2) + \Delta\alpha_{\rm had}^{(5)}(M_Z^2) + \Delta\alpha_{\rm top}(M_Z^2)\,. \]

Returns
\(\Delta\alpha(M_Z^2)\)

Definition at line 925 of file StandardModel/src/StandardModel.cpp.

926{
929 return DeltaAlpha_cache;
930
931 double Mz2 = Mz*Mz;
933 useDeltaAlpha_cache = true;
934 return DeltaAlpha_cache;
935}
const double DeltaAlphaTop(const double s) const
Top-quark contribution to the electromagnetic coupling , denoted as .
const double DeltaAlphaL5q() const
The sum of the leptonic and the five-flavour hadronic corrections to the electromagnetic coupling at...

◆ DeltaAlphaL5q()

const double StandardModel::DeltaAlphaL5q ( ) const

The sum of the leptonic and the five-flavour hadronic corrections to the electromagnetic coupling \(\alpha\) at the \(Z\)-mass scale, denoted as \(\Delta\alpha^{\ell+5q}(M_Z^2)\).

\[ \Delta\alpha^{\ell+5q}(M_Z^2) = \Delta\alpha_{\rm lept}(M_Z^2) + \Delta\alpha_{\rm had}^{(5)}(M_Z^2)\,. \]

Returns
\(\Delta\alpha^{\ell+5q}(M_Z^2)\)

Definition at line 900 of file StandardModel/src/StandardModel.cpp.

901{
902 double Mz2 = Mz*Mz;
903 return (DeltaAlphaLepton(Mz2) + dAl5hMz);
904}
double dAl5hMz
The five-flavour hadronic contribution to the electromagnetic coupling, . (Non-input parameter)
const double DeltaAlphaLepton(const double s) const
Leptonic contribution to the electromagnetic coupling , denoted as .

◆ DeltaAlphaLepton()

const double StandardModel::DeltaAlphaLepton ( const double  s) const

Leptonic contribution to the electromagnetic coupling \(\alpha\), denoted as \(\Delta\alpha_{\mathrm{lept}}(s)\).

Parameters
[in]sinvariant mass squared
Returns
\(\Delta\alpha_{\mathrm{lept}}(s)\)

Definition at line 872 of file StandardModel/src/StandardModel.cpp.

873{
874 if (s == Mz * Mz)
878
879 double DeltaAlphaL = 0.0;
880 if (flag_order[EW1])
881 DeltaAlphaL += myOneLoopEW->DeltaAlpha_l(s);
882 if (flag_order[EW1QCD1])
883 DeltaAlphaL += myTwoLoopQCD->DeltaAlpha_l(s);
884 if (flag_order[EW1QCD2])
885 DeltaAlphaL += myThreeLoopQCD->DeltaAlpha_l(s);
886 if (flag_order[EW2])
887 DeltaAlphaL += myTwoLoopEW->DeltaAlpha_l(s);
888 if (flag_order[EW2QCD1])
889 DeltaAlphaL += myThreeLoopEW2QCD->DeltaAlpha_l(s);
890 if (flag_order[EW3])
891 DeltaAlphaL += myThreeLoopEW->DeltaAlpha_l(s);
892
893 if (s == Mz * Mz) {
894 DeltaAlphaLepton_cache = DeltaAlphaL;
896 }
897 return DeltaAlphaL;
898}
double DeltaAlpha_l(const double s) const
Leptonic contribution of to the electromagnetic coupling , denoted as .
double DeltaAlpha_l(const double s) const
Leptonic contribution of to the electromagnetic coupling , denoted as .
double DeltaAlpha_l(const double s) const
Leptonic contribution of to the electromagnetic coupling , denoted as .
double DeltaAlpha_l(const double s) const
Leptonic contribution of to the electromagnetic coupling , denoted as .
double DeltaAlpha_l(const double s) const
Leptonic contribution of to the electromagnetic coupling , denoted as .
double DeltaAlpha_l(const double s) const
Leptonic contribution of to the electromagnetic coupling , denoted as .

◆ DeltaAlphaTop()

const double StandardModel::DeltaAlphaTop ( const double  s) const

Top-quark contribution to the electromagnetic coupling \(\alpha\), denoted as \(\Delta\alpha_{\mathrm{top}}(s)\).

Parameters
[in]sinvariant mass squared
Returns
\(\Delta\alpha_{\mathrm{top}}(s)\)

Definition at line 906 of file StandardModel/src/StandardModel.cpp.

907{
908 double DeltaAlpha = 0.0;
909 if (flag_order[EW1])
911 if (flag_order[EW1QCD1])
913 if (flag_order[EW1QCD2])
915 if (flag_order[EW2])
917 if (flag_order[EW2QCD1])
919 if (flag_order[EW3])
921
922 return DeltaAlpha;
923}
double DeltaAlpha_t(const double s) const
Top-quark contribution of to the electromagnetic coupling , denoted as .
double DeltaAlpha_t(const double s) const
Top-quark contribution of to the electromagnetic coupling , denoted as .
double DeltaAlpha_t(const double s) const
Top-quark contribution of to the electromagnetic coupling , denoted as .
double DeltaAlpha_t(const double s) const
Top-quark contribution of to the electromagnetic coupling , denoted as .
double DeltaAlpha_t(const double s) const
Top-quark contribution of to the electromagnetic coupling , denoted as .
double DeltaAlpha_t(const double s) const
Top-quark contribution of to the electromagnetic coupling , denoted as .

◆ deltaKappaZ_f()

const gslpp::complex StandardModel::deltaKappaZ_f ( const Particle  f) const
virtual

Flavour non-universal vertex corrections to \(\kappa_Z^l\), denoted by \(\Delta\kappa_Z^l\).

The non-universal contribution \(\Delta\kappa_Z^l\) is given by

\[ \Delta \kappa_Z^l = \kappa_Z^l - \kappa_Z^e = \frac{\alpha}{4\pi s_W^2} \left( \frac{\delta_l^2-\delta_e^2}{4c_W^2}\,\mathcal{F}_Z(M_Z^2) -u_l+u_e\right), \]

where \(u_l\) and \(\delta_l\) are defined as

\[ u_l = \frac{3v_l^2+a_l^2}{4c_W^2}\mathcal{F}_Z(M_Z^2) + \mathcal{F}_W^l(M_Z^2)\,, \qquad \delta_l = v_l - a_l \]

with the tree-level vector and axial-vector couplings \(v_l = I_3^l - 2Q_l s_W^2\) and \(a_l = I_3^l\), and the form factors \(\mathcal{F}_Z\) and \(\mathcal{F}_W^l\).

See [Ciuchini:2013pca] and references therein.

Parameters
[in]fa lepton or quark
Returns
\(\Delta\kappa_Z^l\)

Definition at line 1763 of file StandardModel/src/StandardModel.cpp.

1764{
1765 Particle p1 = f, pe = leptons[ELECTRON];
1766
1767 if (f.is("TOP") || f.is("ELECTRON")) return (gslpp::complex(0.0, 0.0, false));
1768
1769 /* In the case of BOTTOM, the top contribution has to be subtracted.
1770 * The remaining contribution is the same as that for DOWN and STRANGE. */
1771 if (f.is("BOTTOM")) p1 = quarks[DOWN];
1772
1773 double myMw = Mw();
1774 double cW2 = myMw * myMw / Mz / Mz, sW2 = 1.0 - cW2;
1775 gslpp::complex ul = (3.0 * myEWSMcache->v_f(pe, myMw) * myEWSMcache->v_f(pe, myMw)
1776 + myEWSMcache->a_f(pe) * myEWSMcache->a_f(pe)) / 4.0 / cW2 * myOneLoopEW->FZ(Mz*Mz, myMw)
1777 + myOneLoopEW->FW(Mz*Mz, pe, myMw);
1778 double deltal = myEWSMcache->delta_f(pe, myMw);
1779 gslpp::complex uf = (3.0 * myEWSMcache->v_f(p1, myMw) * myEWSMcache->v_f(p1, myMw)
1780 + myEWSMcache->a_f(p1) * myEWSMcache->a_f(p1)) / 4.0 / cW2 * myOneLoopEW->FZ(Mz*Mz, myMw)
1781 + myOneLoopEW->FW(Mz*Mz, p1, myMw);
1782 double deltaf = myEWSMcache->delta_f(p1, myMw);
1783
1784 gslpp::complex dKappa = (deltaf * deltaf - deltal * deltal) / 4.0 / cW2 * myOneLoopEW->FZ(Mz*Mz, myMw)
1785 - uf + ul;
1786 dKappa *= ale / 4.0 / M_PI / sW2;
1787 return dKappa;
1788}
gslpp::complex FZ(const double s, const double Mw_i) const
The unified form factor .
gslpp::complex FW(const double s, const Particle f, const double Mw_i) const
The unified form factor for .
double a_f(const Particle f) const
The tree-level axial-vector coupling for , denoted as .
Definition: EWSMcache.h:301
double v_f(const Particle f, const double Mw_i) const
The tree-level vector coupling for , denoted as .
Definition: EWSMcache.h:290
double delta_f(const Particle f, const double Mw_i) const
.
Definition: EWSMcache.h:323
bool is(std::string name_i) const
Definition: Particle.cpp:23

◆ DeltaR()

const double StandardModel::DeltaR ( ) const
virtual

The SM prediction for \(\Delta r\) derived from that for the \(W\) boson mass.

If the model flag Mw of StandardModel is set to NORESUM or APPROXIMATEFORMULA, the quantity \(\Delta r\) is computed by using the following relation:

\[ s_W^2 M_W^2 = \frac{\pi\,\alpha}{\sqrt{2}G_\mu}(1+\Delta r)\,. \]

Otherwise, the following relation is employed instead:

\[ s_W^2 M_W^2 = \frac{\pi\,\alpha}{\sqrt{2}G_\mu(1-\Delta r)}\,, \]

where the resummation for \(\Delta r\) is considered.

Returns
\(\Delta r_{\mathrm{SM}}\)
See also
The corresponding quantity in the complex-pole/fixed-width scheme (instead of the experimental/running-widthr scheme) is defined in DeltaRbar_SM().

Definition at line 1111 of file StandardModel/src/StandardModel.cpp.

1112{
1113 /* in the experimental/running-width scheme */
1114 double myMw = Mw();
1115 double sW2 = 1.0 - myMw * myMw / Mz / Mz;
1116 double tmp = sqrt(2.0) * GF * sW2 * myMw * myMw / M_PI / ale;
1117 if (FlagMw.compare("NORESUM") == 0
1118 || FlagMw.compare("APPROXIMATEFORMULA") == 0) {
1119 return (tmp - 1.0);
1120 } else {
1121 return (1.0 - 1.0 / tmp);
1122 }
1123}

◆ DeltaRbar()

const double StandardModel::DeltaRbar ( ) const
virtual

The SM prediction for \(\Delta \overline{r}\) derived from that for the \(W\)-boson mass.

The quantity \(\Delta \overline{r}\) is computed by using the following relation:

\[ \overline{s}_W^2 \overline{M}_W^2 = \frac{\pi\,\alpha}{\sqrt{2}G_\mu}(1+\Delta \overline{r})\,, \]

where \(\overline{M}_W\) and \(\overline{s}_W\) are the \(W\)-boson mass and the sine of the weak mixing angle in the complex-pole/fixed-width scheme [Bardin:1988xt].

Returns
\(\Delta \overline{r}_{\mathrm{SM}}\)
See also
DeltaR_SM(), defining the corresponding quantity in the experimental/running-width scheme.

Definition at line 1221 of file StandardModel/src/StandardModel.cpp.

1222{
1223 double Mwbar_SM = MwbarFromMw(Mw());
1224 double sW2bar = 1.0 - Mwbar_SM * Mwbar_SM / Mzbar() / Mzbar();
1225 double tmp = sqrt(2.0) * GF * sW2bar * Mwbar_SM * Mwbar_SM / M_PI / ale;
1226
1227 return (tmp - 1.0);
1228}
double Mzbar() const
The -boson mass in the complex-pole/fixed-width scheme.
const double MwbarFromMw(const double Mw) const
A method to convert the -boson mass in the experimental/running-width scheme to that in the complex-p...

◆ deltaRhoZ_f()

const gslpp::complex StandardModel::deltaRhoZ_f ( const Particle  f) const
virtual

Flavour non-universal vertex corrections to \(\rho_Z^l\), denoted by \(\Delta\rho_Z^l\).

The non-universal contribution \(\Delta\rho_Z^l\) is given by

\[ \Delta \rho_Z^l = \rho_Z^l - \rho_Z^e = \frac{\alpha}{2\pi s_W^2}\left(u_l - u_e\right), \]

where \(u_l\) is defined as

\[ u_l = \frac{3v_l^2+a_l^2}{4c_W^2}\mathcal{F}_Z(M_Z^2) + \mathcal{F}_W^l(M_Z^2) \]

with the tree-level vector and axial-vector couplings \(v_l = I_3^l - 2Q_l s_W^2\) and \(a_l = I_3^l\) and the form factors, \(\mathcal{F}_Z\) and \(\mathcal{F}_W^l\).

See [Ciuchini:2013pca] and references therein.

Parameters
[in]fa lepton or quark
Returns
\(\Delta\rho_Z^l\)

Definition at line 1738 of file StandardModel/src/StandardModel.cpp.

1739{
1740 Particle p1 = f, pe = leptons[ELECTRON];
1741
1742 if (f.is("TOP") || f.is("ELECTRON")) return (gslpp::complex(0.0, 0.0, false));
1743
1744 /* In the case of BOTTOM, the top contribution has to be subtracted.
1745 * The remaining contribution is the same as that for DOWN and STRANGE. */
1746 if (f.is("BOTTOM")) p1 = quarks[DOWN];
1747
1748 double myMw = Mw();
1749 double cW2 = myMw * myMw / Mz / Mz, sW2 = 1.0 - cW2;
1750
1751 gslpp::complex ul = (3.0 * myEWSMcache->v_f(pe, myMw) * myEWSMcache->v_f(pe, myMw)
1752 + myEWSMcache->a_f(pe) * myEWSMcache->a_f(pe)) / 4.0 / cW2 * myOneLoopEW->FZ(Mz*Mz, myMw)
1753 + myOneLoopEW->FW(Mz*Mz, pe, myMw);
1754 gslpp::complex uf = (3.0 * myEWSMcache->v_f(p1, myMw) * myEWSMcache->v_f(p1, myMw)
1755 + myEWSMcache->a_f(p1) * myEWSMcache->a_f(p1)) / 4.0 / cW2 * myOneLoopEW->FZ(Mz*Mz, myMw)
1756 + myOneLoopEW->FW(Mz*Mz, p1, myMw);
1757
1758 gslpp::complex dRho = 2.0 * (uf - ul);
1759 dRho *= ale / 4.0 / M_PI / sW2;
1760 return dRho;
1761}

◆ eeffAFBbottom()

virtual const double StandardModel::eeffAFBbottom ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3257 of file StandardModel.h.

3258 {
3259 return ( ( eeffsigma(quarks[BOTTOM], pol_e, pol_p, s, 0.0, 1.0) - eeffsigma(quarks[BOTTOM], pol_e, pol_p, s, -1.0, 0.0) ) / eeffsigma(quarks[BOTTOM], pol_e, pol_p, s, -1.0, 1.0) );
3260 }
const double eeffsigma(const Particle f, const double pol_e, const double pol_p, const double s, const double cosmin, const double cosmax) const

◆ eeffAFBcharm()

virtual const double StandardModel::eeffAFBcharm ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3253 of file StandardModel.h.

3254 {
3255 return ( ( eeffsigma(quarks[CHARM], pol_e, pol_p, s, 0.0, 1.0) - eeffsigma(quarks[CHARM], pol_e, pol_p, s, -1.0, 0.0) ) / eeffsigma(quarks[CHARM], pol_e, pol_p, s, -1.0, 1.0) );
3256 }

◆ eeffAFBe()

virtual const double StandardModel::eeffAFBe ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3227 of file StandardModel.h.

3228 {
3229 double cosmin = -0.90; // As in LEP2
3230 double cosmax = 0.90; // As in LEP2
3231
3232 return (( eeffsigmaEbin(pol_e, pol_p, s, 0.0 , cosmax) - eeffsigmaEbin(pol_e, pol_p, s, cosmin, 0.0) ) / eeffsigmaEbin(pol_e, pol_p, s, cosmin, cosmax));
3233 }
const double eeffsigmaEbin(const double pol_e, const double pol_p, const double s, const double cosmin, const double cosmax) const

◆ eeffAFBetsub()

virtual const double StandardModel::eeffAFBetsub ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3234 of file StandardModel.h.

3235 {
3236 double cosmin = -0.90; // As in LEP2
3237 double cosmax = 0.90; // As in LEP2
3238
3239 return ( ( eeffsigma(leptons[ELECTRON], pol_e, pol_p, s, 0.0 , cosmax) - eeffsigma(leptons[ELECTRON], pol_e, pol_p, s, cosmin, 0.0) ) / eeffsigma(leptons[ELECTRON], pol_e, pol_p, s, cosmin, cosmax) );
3240 }

◆ eeffAFBmu()

virtual const double StandardModel::eeffAFBmu ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3241 of file StandardModel.h.

3242 {
3243 return ( ( eeffsigma(leptons[MU], pol_e, pol_p, s, 0.0, 1.0) - eeffsigma(leptons[MU], pol_e, pol_p, s, -1.0, 0.0) ) / eeffsigma(leptons[MU], pol_e, pol_p, s, -1.0, 1.0) );
3244 }

◆ eeffAFBstrange()

virtual const double StandardModel::eeffAFBstrange ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3249 of file StandardModel.h.

3250 {
3251 return ( ( eeffsigma(quarks[STRANGE], pol_e, pol_p, s, 0.0, 1.0) - eeffsigma(quarks[STRANGE], pol_e, pol_p, s, -1.0, 0.0) ) / eeffsigma(quarks[STRANGE], pol_e, pol_p, s, -1.0, 1.0) );
3252 }

◆ eeffAFBtau()

virtual const double StandardModel::eeffAFBtau ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3245 of file StandardModel.h.

3246 {
3247 return ( ( eeffsigma(leptons[TAU], pol_e, pol_p, s, 0.0, 1.0) - eeffsigma(leptons[TAU], pol_e, pol_p, s, -1.0, 0.0) ) / eeffsigma(leptons[TAU], pol_e, pol_p, s, -1.0, 1.0) );
3248 }

◆ eeffRbottom()

virtual const double StandardModel::eeffRbottom ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3220 of file StandardModel.h.

3221 {
3222 return ( eeffsigmaBottom(pol_e, pol_p, s) / eeffsigmaHadron(pol_e, pol_p, s) );
3223 }
virtual const double eeffsigmaBottom(const double pol_e, const double pol_p, const double s) const
virtual const double eeffsigmaHadron(const double pol_e, const double pol_p, const double s) const

◆ eeffRcharm()

virtual const double StandardModel::eeffRcharm ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3216 of file StandardModel.h.

3217 {
3218 return ( eeffsigmaCharm(pol_e, pol_p, s) / eeffsigmaHadron(pol_e, pol_p, s) );
3219 }
virtual const double eeffsigmaCharm(const double pol_e, const double pol_p, const double s) const

◆ eeffRelectron()

virtual const double StandardModel::eeffRelectron ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3196 of file StandardModel.h.

3197 {
3198 return ( eeffsigmaHadron(pol_e, pol_p, s) / eeffsigmaE(pol_e, pol_p, s) );
3199 }
virtual const double eeffsigmaE(const double pol_e, const double pol_p, const double s) const

◆ eeffRelectrontsub()

virtual const double StandardModel::eeffRelectrontsub ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3200 of file StandardModel.h.

3201 {
3202 return ( eeffsigmaHadron(pol_e, pol_p, s) / eeffsigmaEtsub(pol_e, pol_p, s) );
3203 }
virtual const double eeffsigmaEtsub(const double pol_e, const double pol_p, const double s) const

◆ eeffRmuon()

virtual const double StandardModel::eeffRmuon ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3204 of file StandardModel.h.

3205 {
3206 return ( eeffsigmaHadron(pol_e, pol_p, s) / eeffsigmaMu(pol_e, pol_p, s) );
3207 }
virtual const double eeffsigmaMu(const double pol_e, const double pol_p, const double s) const

◆ eeffRstrange()

virtual const double StandardModel::eeffRstrange ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3212 of file StandardModel.h.

3213 {
3214 return ( eeffsigmaStrange(pol_e, pol_p, s) / eeffsigmaHadron(pol_e, pol_p, s) );
3215 }
virtual const double eeffsigmaStrange(const double pol_e, const double pol_p, const double s) const

◆ eeffRtau()

virtual const double StandardModel::eeffRtau ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3208 of file StandardModel.h.

3209 {
3210 return ( eeffsigmaHadron(pol_e, pol_p, s) / eeffsigmaTau(pol_e, pol_p, s) );
3211 }
virtual const double eeffsigmaTau(const double pol_e, const double pol_p, const double s) const

◆ eeffsigma()

const double StandardModel::eeffsigma ( const Particle  f,
const double  pol_e,
const double  pol_p,
const double  s,
const double  cosmin,
const double  cosmax 
) const

Definition at line 4047 of file StandardModel/src/StandardModel.cpp.

4047 {
4048 // Only valid for f=/=e (MLL2, MRR2 do not depend on t for f=/=e. Simply enter t=1 as argument)
4049 // For f=e this corresponds to t-subtracted definition from LEP
4050 double sumM2, sigma;
4051 double tdumm = 1.;
4052 double topb = 0.3894e+9;
4053
4054 //double cosmin = -1.0;
4055 //double cosmax = 1.0;
4056
4057 double Nf;
4058
4059 double pLH, pRH; //Polarization factors, minus the 1/4 average
4060
4061 pLH = (1.0 - pol_e) * (1.0 + pol_p);
4062 pRH = (1.0 + pol_e) * (1.0 - pol_p);
4063
4064 if (f.is("LEPTON")) {
4065 Nf = 1.0;
4066 } else {
4067 Nf = 3.0;
4068 }
4069
4070 sumM2 = (pLH * MLR2eeff(f, s) + pRH * MRL2eeff(f, s)) * tovers2(cosmin, cosmax)
4071 + (pLH * MLL2eeff(f, s, tdumm) + pRH * MRR2eeff(f, s, tdumm)) * uovers2(cosmin, cosmax);
4072
4073 sigma = Nf * 0.5 * M_PI * (alphaMz())*(alphaMz()) * sumM2 / s;
4074
4075 return topb * sigma;
4076}
const double MRL2eeff(const Particle f, const double s) const
const double uovers2(const double cosmin, const double cosmax) const
const double tovers2(const double cosmin, const double cosmax) const
const double MLL2eeff(const Particle f, const double s, const double t) const
const double MRR2eeff(const Particle f, const double s, const double t) const
const double MLR2eeff(const Particle f, const double s) const

◆ eeffsigmaBottom()

virtual const double StandardModel::eeffsigmaBottom ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3189 of file StandardModel.h.

3190 {
3191 return eeffsigma(quarks[BOTTOM], pol_e, pol_p, s, -1.0, 1.0);
3192 }

◆ eeffsigmaCharm()

virtual const double StandardModel::eeffsigmaCharm ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3184 of file StandardModel.h.

3185 {
3186 return eeffsigma(quarks[CHARM], pol_e, pol_p, s, -1.0, 1.0);
3187 }

◆ eeffsigmaE()

virtual const double StandardModel::eeffsigmaE ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3144 of file StandardModel.h.

3145 {
3146 double cosmin = -0.90; // As in LEP2
3147 double cosmax = 0.90; // As in LEP2
3148
3149 return eeffsigmaEbin(pol_e, pol_p, s, cosmin, cosmax);
3150 }

◆ eeffsigmaEbin()

const double StandardModel::eeffsigmaEbin ( const double  pol_e,
const double  pol_p,
const double  s,
const double  cosmin,
const double  cosmax 
) const

Definition at line 4018 of file StandardModel/src/StandardModel.cpp.

4018 {
4019
4020 double sumM2, sigma;
4021 double topb = 0.3894e+9;
4022 double t0, t1, lambdaK;
4023
4024 double pLH, pRH; //Polarization factors, minus the 1/4 average
4025
4026 pLH = (1.0 - pol_e) * (1.0 + pol_p);
4027 pRH = (1.0 + pol_e) * (1.0 - pol_p);
4028
4029 // t values for cosmin and cosmax
4030 t0 = 0.5 * s * ( -1.0 + cosmin );
4031 t1 = 0.5 * s * ( -1.0 + cosmax );
4032
4033 // Kähllén function of (s,0,0)
4034 lambdaK = s*s;
4035
4036 // Sum of the integrals of the amplitudes squared x (t/s)^2, (s/t)^2, (u/s)^2
4037 sumM2 = (pLH + pRH) * ( intMLR2eeeets2(s, t0, t1) + intMLRtilde2eeeest2(s, t0, t1) ) +
4038 pLH * intMLL2eeeeus2(s, t0, t1) + pRH * intMRR2eeeeus2(s, t0, t1);
4039
4040 // Build the cross section
4041 sigma = M_PI * (alphaMz())*(alphaMz()) * sumM2 / s / sqrt(lambdaK);
4042
4043 return topb * sigma;
4044
4045}
const double intMLR2eeeets2(const double s, const double t0, const double t1) const
const double intMLRtilde2eeeest2(const double s, const double t0, const double t1) const
const double intMRR2eeeeus2(const double s, const double t0, const double t1) const
const double intMLL2eeeeus2(const double s, const double t0, const double t1) const

◆ eeffsigmaEtsub()

virtual const double StandardModel::eeffsigmaEtsub ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3154 of file StandardModel.h.

3155 {
3156 double cosmin = -0.90; // As in LEP2
3157 double cosmax = 0.90; // As in LEP2
3158
3159 return eeffsigma(leptons[ELECTRON], pol_e, pol_p, s, cosmin, cosmax);
3160 }

◆ eeffsigmaHadron()

virtual const double StandardModel::eeffsigmaHadron ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3172 of file StandardModel.h.

3173 {
3174 return ( eeffsigma(quarks[UP], pol_e, pol_p, s, -1.0, 1.0) + eeffsigma(quarks[DOWN], pol_e, pol_p, s, -1.0, 1.0)
3175 + eeffsigma(quarks[CHARM], pol_e, pol_p, s, -1.0, 1.0) + eeffsigma(quarks[STRANGE], pol_e, pol_p, s, -1.0, 1.0)
3176 + eeffsigma(quarks[BOTTOM], pol_e, pol_p, s, -1.0, 1.0) );
3177 }

◆ eeffsigmaMu()

virtual const double StandardModel::eeffsigmaMu ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3162 of file StandardModel.h.

3163 {
3164 return eeffsigma(leptons[MU], pol_e, pol_p, s, -1.0, 1.0);
3165 }

◆ eeffsigmaStrange()

virtual const double StandardModel::eeffsigmaStrange ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3179 of file StandardModel.h.

3180 {
3181 return eeffsigma(quarks[STRANGE], pol_e, pol_p, s, -1.0, 1.0);
3182 }

◆ eeffsigmaTau()

virtual const double StandardModel::eeffsigmaTau ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 3167 of file StandardModel.h.

3168 {
3169 return eeffsigma(leptons[TAU], pol_e, pol_p, s, -1.0, 1.0);
3170 }

◆ epsilon1()

const double StandardModel::epsilon1 ( ) const
virtual

The SM contribution to the epsilon parameter \(\varepsilon_1\).

The parameters \(\varepsilon_1\) is defined as

\[ \varepsilon_1 = \Delta\rho'\,, \]

where \(\Delta\rho'=2\left(\sqrt{{\rm Re}(\rho_Z^e)}-1\right)\).

See [Altarelli:1990zd] and [Altarelli:1991fk].

Returns
\(\varepsilon_{1,\mathrm{SM}}\)

Reimplemented in NPEpsilons, NPEpsilons_pureNP, NPSTU, and NPSTUVWXY.

Definition at line 1793 of file StandardModel/src/StandardModel.cpp.

1794{
1795 double rhoZe = rhoZ_f(leptons[ELECTRON]).real();
1796 double DeltaRhoPrime = 2.0 * (sqrt(rhoZe) - 1.0);
1797
1798 return DeltaRhoPrime;
1799}
virtual const gslpp::complex rhoZ_f(const Particle f) const
The effective leptonic neutral-current coupling in the SM.

◆ epsilon2()

const double StandardModel::epsilon2 ( ) const
virtual

The SM contribution to the epsilon parameter \(\varepsilon_2\).

The parameters \(\varepsilon_2\) is computed via the formula:

\[ \varepsilon_2 = c_0^2 \Delta\rho' + \frac{s_0^2}{c_0^2 - s_0^2} \Delta r_W - 2 s_0^2 \Delta\kappa'\,, \]

where \(\Delta\rho'\), \(\Delta r_W\) and \(\Delta\kappa'\) are defined as

\begin{align} \Delta\rho'=2\left(\sqrt{{\rm Re}(\rho_Z^e)}-1\right),\qquad \Delta r_W = 1 - \frac{\pi\,\alpha(M_Z^2)}{\sqrt{2}\,G_\mu M_Z^2 s_W^2 c_W^2},\qquad \Delta\kappa' = \frac{\sin^2\theta_{\mathrm{eff}}^e}{s_0^2} - 1\,, \end{align}

and \(s_0^2\) and \(c_0^2\) are given in s02() and c02(), respectively.

See [Altarelli:1990zd] and [Altarelli:1991fk].

Returns
\(\varepsilon_{2,\mathrm{SM}}\)

Reimplemented in NPEpsilons, NPEpsilons_pureNP, NPSTU, and NPSTUVWXY.

Definition at line 1801 of file StandardModel/src/StandardModel.cpp.

1802{
1803 double rhoZe = rhoZ_f(leptons[ELECTRON]).real();
1804 double sin2thetaEff = kappaZ_f(leptons[ELECTRON]).real() * sW2();
1805 double DeltaRhoPrime = 2.0 * (sqrt(rhoZe) - 1.0);
1806 double DeltaKappaPrime = sin2thetaEff / s02() - 1.0;
1807 double DeltaRW = 1.0 - M_PI * alphaMz() / (sqrt(2.0) * GF * Mz * Mz * sW2() * cW2());
1808
1809 return ( c02() * DeltaRhoPrime + s02() * DeltaRW / (c02() - s02())
1810 - 2.0 * s02() * DeltaKappaPrime);
1811}
const double c02() const
The square of the cosine of the weak mixing angle defined without weak radiative corrections.
An observable class for the leptonic effective weak mixing angle at the pole. To be used for the el...
Definition: sin2thetaEff.h:29

◆ epsilon3()

const double StandardModel::epsilon3 ( ) const
virtual

The SM contribution to the epsilon parameter \(\varepsilon_3\).

The parameters \(\varepsilon_3\) is computed via the formula:

\[ \varepsilon_3 = c_0^2\Delta\rho' + (c_0^2-s_0^2)\Delta\kappa'\,, \]

where \(\Delta\rho'\) and \(\Delta\kappa'\) are defined as

\begin{align} \Delta\rho'=2\left(\sqrt{{\rm Re}(\rho_Z^e)}-1\right),\qquad \Delta\kappa' = \frac{\sin^2\theta_{\mathrm{eff}}^e}{s_0^2} - 1\,, \end{align}

and \(s_0^2\) and \(c_0^2\) are given in s02() and c02(), respectively.

See [Altarelli:1990zd] and [Altarelli:1991fk].

Returns
\(\varepsilon_{3,\mathrm{SM}}\)

Reimplemented in NPEpsilons, NPEpsilons_pureNP, NPSTU, and NPSTUVWXY.

Definition at line 1813 of file StandardModel/src/StandardModel.cpp.

1814{
1815 double rhoZe = rhoZ_f(leptons[ELECTRON]).real();
1816 double sin2thetaEff = kappaZ_f(leptons[ELECTRON]).real() * sW2();
1817 double DeltaRhoPrime = 2.0 * (sqrt(rhoZe) - 1.0);
1818 double DeltaKappaPrime = sin2thetaEff / s02() - 1.0;
1819
1820 return ( c02() * DeltaRhoPrime + (c02() - s02()) * DeltaKappaPrime);
1821}

◆ epsilonb()

const double StandardModel::epsilonb ( ) const
virtual

The SM contribution to the epsilon parameter \(\varepsilon_b\).

The parameters \(\varepsilon_b\) is computed via the formula:

\[ \epsilon_b = \frac{ {\rm Re}\left[ \kappa_Z^e + \Delta\kappa_Z^b \right]} {{\rm Re}(\kappa_Z^b)} - 1\,, \]

where \(\Delta\kappa_Z^b\), representing flavour non-universal vertex corrections to the \(Zb\bar{b}\) vertex, is neglected when the model flag WithoutNonUniversalVC of StandardModel is set to true.

See [Altarelli:1990zd], [Altarelli:1991fk] and [Altarelli:1993sz] for the \(\varepsilon\) parameterization and [Ciuchini:2013pca] for the flavour non-universal vertex corrections.

Returns
\(\varepsilon_{b,\mathrm{SM}}\)

Reimplemented in NPEpsilons, NPEpsilons_pureNP, NPSTU, and NPSTUVWXY.

Definition at line 1823 of file StandardModel/src/StandardModel.cpp.

1824{
1825 /* epsilon_b from g_A^b
1826 * see Eq.(13) of IJMP A7, 1031 (1998) by Altarelli et al. */
1827 //double rhoZe = rhoZ_l_SM(StandardModel::ELECTRON).real();
1828 //double rhoZb = rhoZ_q_SM(QCD::BOTTOM).real();
1829 //double DeltaRhoPrime = 2.0*( sqrt(rhoZe) - 1.0 );
1830 //double eps1 = DeltaRhoPrime;
1831 //return ( - 1.0 + sqrt(rhoZb)/(1.0 + eps1/2.0) );
1832
1833 /* epsilon_b from Re(g_V^b/g_A^b), i.e. Re(kappaZ_b)
1834 * see Eq.(13) of IJMP A7, 1031 (1998) by Altarelli et al. */
1835 gslpp::complex kappaZe = kappaZ_f(leptons[ELECTRON]);
1836 gslpp::complex kappaZb = kappaZ_f(quarks[BOTTOM]);
1838 return ( kappaZe.real() / kappaZb.real() - 1.0);
1839 else
1840 return ( (kappaZe.real() + deltaKappaZ_f(quarks[BOTTOM]).real())
1841 / kappaZb.real() - 1.0);
1842
1843 /* epsilon_b from Gamma_b via Eqs.(11), (12) and (16) of IJMP A7,
1844 * 1031 (1998) by Altarelli et al.
1845 * Note: mb has to be mb=4.7, since Eq.(16) were derived with this value.
1846 */
1847 //double als_Mz = Als(myCache->Mz(), FULLNNLO);
1848 //double delta_als = (als_Mz - 0.119)/M_PI;
1849 //double delta_alpha = (alphaMz() - 1.0/128.90)/myCache->ale();
1850 //double Gamma_b_Born = 0.3798*( 1.0 + delta_als - 0.42*delta_alpha);
1851 //double a = als_Mz/M_PI;
1852 //double RQCD = 1.0 + 1.2*a - 1.1*a*a - 13.0*a*a*a;
1853 //double mb = Mrun(myCache->Mz(), quarks[QCD::BOTTOM].getMass(), FULLNNLO);// This is wrong!
1854 //double mb = 4.7;
1855 //std::cout << "mb = " << mb << std::endl;
1856 //double beta = sqrt(1.0 - 4.0*mb*mb/myCache->Mz()/myCache->Mz());
1857 //double Nc = 3.0;
1858 //double factor = myCache->GF()*myCache->Mz()*myCache->Mz()*myCache->Mz()/6.0/M_PI/sqrt(2.0);
1859 //double Gamma_b = factor*beta*((3.0 - beta*beta)/2.0*gVq_SM(QCD::BOTTOM).abs2()
1860 // + beta*beta*gAq_SM(QCD::BOTTOM).abs2())
1861 // *Nc*RQCD*(1.0 + alphaMz()/12.0/M_PI);
1862 //return ( (Gamma_b/Gamma_b_Born - 1.0 - 1.42*epsilon1_SM()
1863 // + 0.54*epsilon3_SM() )/2.29 );
1864}
const bool IsFlagWithoutNonUniversalVC() const
A method to retrieve the model flag WithoutNonUniversalVC.
virtual const gslpp::complex deltaKappaZ_f(const Particle f) const
Flavour non-universal vertex corrections to , denoted by .

◆ f_triangle()

gslpp::complex StandardModel::f_triangle ( const double  tau) const

Loop function entering in the calculation of the effective \(Hgg\) and \(H\gamma\gamma\) couplings.

Parameters
[in]

_form#4314, with \(M\) the mass of the particle in the loop.

Returns
\(f(\tau)\)

Definition at line 3255 of file StandardModel/src/StandardModel.cpp.

3255 {
3256 gslpp::complex tmp;
3257 if (tau >= 1.0) {
3258 tmp = asin(1.0 / sqrt(tau));
3259 return (tmp * tmp);
3260 } else {
3261 tmp = log((1.0 + sqrt(1.0 - tau)) / (1.0 - sqrt(1.0 - tau))) - M_PI * gslpp::complex::i();
3262 return (-0.25 * tmp * tmp);
3263 }
3264}

◆ g_triangle()

gslpp::complex StandardModel::g_triangle ( const double  tau) const

Loop function entering in the calculation of the effective \(HZ\gamma\) coupling.

Parameters
[in]

_form#4314, with \(M\) the mass of the particle in the loop.

Returns
\(g(\tau)\)

Definition at line 3266 of file StandardModel/src/StandardModel.cpp.

3266 {
3267 gslpp::complex tmp;
3268 if (tau >= 1.0) {
3269 tmp = sqrt(tau - 1.0) * asin(1.0 / sqrt(tau));
3270 return tmp;
3271 } else {
3272 tmp = sqrt(1.0 - tau) * (log((1.0 + sqrt(1.0 - tau)) / (1.0 - sqrt(1.0 - tau))) - M_PI * gslpp::complex::i());
3273 return 0.5 * tmp;
3274 }
3275}

◆ gA_f()

const gslpp::complex StandardModel::gA_f ( const Particle  f) const
virtual

The effective leptonic neutral-current axial-vector coupling \(g_A^l\) in the SM.

\[ g_A^l = \sqrt{\rho_Z^l}\, I_3^l\,. \]

Parameters
[in]fa lepton or quark
Returns
\(g_{A,\,\mathrm{SM}}^l\)

Reimplemented in NPbase, and NPEpsilons.

Definition at line 1582 of file StandardModel/src/StandardModel.cpp.

1583{
1584 return ( sqrt(rhoZ_f(f)) * f.getIsospin());
1585}
double getIsospin() const
A get method to access the particle isospin.
Definition: Particle.h:115

◆ Gamma_had()

const double StandardModel::Gamma_had ( ) const
virtual

The hadronic decay width of the \(Z\) boson, \(\Gamma_{h}\).

The hadronic width is given by the sum,

\[ \Gamma_h = \Gamma_u + \Gamma_d + \Gamma_c + \Gamma_s + \Gamma_b\,. \]

Furthermore, the singlet vector corrections are added, following the prescription in [Bardin:1997xq] :

\[ \Gamma_h = \sum_q \Gamma_q + 4N_c\Gamma_0 R_V^h\,. \]

Returns
\(\Gamma_{h}\) in GeV

Reimplemented in NPbase.

Definition at line 1410 of file StandardModel/src/StandardModel.cpp.

1411{
1412 double Gamma_had_tmp = 0.0;
1413
1415
1416 /* SM contribution with the approximate formula */
1417 return myApproximateFormulae->X_full("Gamma_had");
1418
1419 } else {
1420
1421 Gamma_had_tmp = GammaZ(quarks[UP]) + GammaZ(quarks[DOWN]) + GammaZ(quarks[CHARM])
1423
1424 /* Singlet vector contribution (not included in the approximate formula) */
1425 double G0 = GF * pow(Mz, 3.0) / 24.0 / sqrt(2.0) / M_PI;
1426 Gamma_had_tmp += 4.0 * 3.0 * G0 * RVh();
1427
1428 return Gamma_had_tmp;
1429 }
1430}
double X_full(const std::string observable) const
, , , , , , , , , , , or .
virtual const double GammaZ(const Particle f) const
The partial decay width, .
const bool IsFlagNoApproximateGammaZ() const
A method to retrieve the model flag NoApproximateGammaZ.
double RVh() const
The singlet vector corrections to the hadronic -boson width, denoted as .

◆ Gamma_inv()

const double StandardModel::Gamma_inv ( ) const
virtual

The invisible partial decay width of the \(Z\) boson, \(\Gamma_{\mathrm{inv}}\).

\[ \Gamma_{\mathrm{inv}} = 3\,\Gamma_\nu\,, \]

where \(\Gamma_{\nu}\) is the partial width for \(Z\to\nu\bar{\nu}\).

Returns
\(\Gamma_{\mathrm{inv}}\) in GeV

Definition at line 1404 of file StandardModel/src/StandardModel.cpp.

1405{
1408}

◆ Gamma_muon()

const double StandardModel::Gamma_muon ( ) const
virtual

The computation of the muon decay.

Follows the formulae of PDG

Returns
\(\Gamma_\mu \)

Definition at line 3087 of file StandardModel/src/StandardModel.cpp.

3088{
3089 double Gamma;
3090 double me, mmu, x, Fx, H1x, H2x, H3x, zeta3;
3091 double alpha, rEW;
3092 double pi2;
3093
3094 me = leptons[ELECTRON].getMass();
3095 mmu = leptons[MU].getMass();
3096 pi2 = M_PI*M_PI;
3097
3098 x = me*me/mmu/mmu;
3099 Fx = 1. - 8. * x + 8. * x*x*x - x*x*x*x -12. * x*x * log(x);
3100
3101 H1x = 25./8. - pi2/2. - (9. + 4. *pi2 + 12. * log(x) )*x + 16. * pi2 * pow(x,3./2.);
3102
3103 zeta3 = 1.2020569031595942;
3104
3105 H2x= 156815./5184. - 518. * pi2/81. - 895. *zeta3/36. + 67.*pi2*pi2/720. + 53. *pi2*log(2.)/6. - 0.042 - (5./4.) * pi2*sqrt(x);
3106
3107 H3x = -15.3;
3108
3109 // alpha(m_mu)
3110 alpha = 1./ale - log(x)/3./M_PI; // + 1./6./M_PI;
3111 alpha = 1./alpha;
3112
3113 // Rad. corrections
3114 rEW = 1. + H1x * alpha/M_PI + H2x * alpha*alpha/pi2 + H3x * alpha * alpha *alpha/pi2/M_PI;
3115
3116 // Gamma: PDG formula
3117 Gamma = GF*GF*pow(mmu,5)*Fx*rEW/192./pow(M_PI,3);
3118
3119 return Gamma;
3120}
double zeta3
computed with the GSL.
Definition: QCD.h:1033

◆ Gamma_tau_l_nunu()

const double StandardModel::Gamma_tau_l_nunu ( const Particle  l) const
virtual

The computation of the leptonic tau decays.

Follows the formulae of PDG for muon, adapted to tau leptons

Returns
\(\Gamma(\tau \to l \nu \nu ) \)

Definition at line 3127 of file StandardModel/src/StandardModel.cpp.

3128{
3129 double Gamma;
3130 double ml, mtau, x, Fx, H1x, H2x, H3x, zeta3;
3131 double alpha, rEW;
3132 double pi2;
3133
3134 ml = l.getMass();
3135 mtau = leptons[TAU].getMass();
3136 pi2 = M_PI*M_PI;
3137
3138 x = ml*ml/mtau/mtau;
3139 Fx = 1. - 8. * x + 8. * x*x*x - x*x*x*x -12. * x*x * log(x);
3140
3141 H1x = 25./8. - pi2/2. - (9. + 4. *pi2 + 12. * log(x) )*x + 16. * pi2 * pow(x,3./2.);
3142
3143 zeta3 = 1.2020569031595942;
3144
3145 H2x= 156815./5184. - 518. * pi2/81. - 895. *zeta3/36. + 67.*pi2*pi2/720. + 53. *pi2*log(2.)/6. - 0.042 - (5./4.) * pi2*sqrt(x);
3146
3147 H3x = -15.3;
3148
3149 // alpha(m_tau)
3150 alpha = 1./133.29; // Improve
3151
3152 // Rad. corrections
3153 rEW = 1. + H1x * alpha/M_PI + H2x * alpha*alpha/pi2 + H3x * alpha * alpha *alpha/pi2/M_PI;
3154
3155 // Gamma: PDG formula
3156 Gamma = GF*GF*pow(mtau,5)*Fx*rEW/192./pow(M_PI,3);
3157
3158 return Gamma;
3159}

◆ Gamma_Z()

const double StandardModel::Gamma_Z ( ) const
virtual

The total decay width of the \(Z\) boson, \(\Gamma_Z\).

When checkNPZff_linearized() returns true and the model flag NoApproximateGammaZ of StandardModel is set to false, this function uses the two-loop approximate formula of \(\Gamma_Z\) via EWSMApproximateFormulae::X_full_2_loop(). Otherwise, the total decay width is calculated with

\[ \Gamma_Z = \Gamma_{e} + \Gamma_{\mu} + \Gamma_{\tau} + \Gamma_{\mathrm{inv}} + \Gamma_h\,. \]

Returns
\(\Gamma_Z\) in GeV

Reimplemented in NPbase, NPEpsilons, NPSMEFTd6General, and NPZbbbar.

Definition at line 1432 of file StandardModel/src/StandardModel.cpp.

1433{
1435
1436 /* SM contribution with the approximate formula */
1437 return myApproximateFormulae->X_full("GammaZ");
1438
1439 } else {
1441 + Gamma_inv() + Gamma_had());
1442 }
1443}
virtual const double Gamma_inv() const
The invisible partial decay width of the boson, .
virtual const double Gamma_had() const
The hadronic decay width of the boson, .

◆ GammaHtobb()

const double StandardModel::GammaHtobb ( ) const
virtual

The \(\Gamma(H\to b \bar{b})\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
\(\Gamma(H\to b \bar{b})\)

Definition at line 3603 of file StandardModel/src/StandardModel.cpp.

3604{
3605 double mf0=quarks[BOTTOM].getMass(), mf;
3606 double beta;
3607 double Nc=3.0;
3608 double gamma;
3609 double asMH,DeltaQCD,Deltamt,NF;
3610
3611 // alfa_s(MH)
3612 asMH = Als(mHl, FULLNLO);
3613
3614 mf = Mrun(mHl, mf0, mf0, BOTTOM, FULLNLO);
3615
3616 beta=1.0-4.0*mf*mf/mHl/mHl;
3617
3618 NF=5;
3619
3620 DeltaQCD = 1 + (asMH/M_PI) * ( 17.0/3.0 + (asMH/M_PI) * ( (35.94 - 1.36*NF) + (164.14 - 25.77*NF + 0.26*NF*NF)*(asMH/M_PI) ) );
3621
3622 Deltamt = (asMH/M_PI) * (asMH/M_PI) * ( 1.57 + (4.0/3.0)*log(mHl/mtpole) + (4.0/9.0) * log(mf/mHl) * log(mf/mHl) );
3623
3624 gamma = Nc * (4.0*GF/sqrt(2.0)) * (mf*mf/16.0/M_PI) * mHl * beta*beta*beta * (DeltaQCD + Deltamt);
3625
3626 return gamma;
3627}
const double Mrun(const double mu, const double m, const quark q, const orders order=FULLNNLO) const
Computes a running quark mass from .
Definition: QCD.cpp:1353

◆ GammaHtocc()

const double StandardModel::GammaHtocc ( ) const
virtual

The \(\Gamma(H\to c \bar{c})\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
\(\Gamma(H\to c \bar{c})\)

Definition at line 3551 of file StandardModel/src/StandardModel.cpp.

3552{
3553 double mf0=quarks[CHARM].getMass(), mf;
3554 double beta;
3555 double Nc=3.0;
3556 double gamma;
3557 double asMH,DeltaQCD,Deltamt,NF;
3558
3559 // alfa_s(MH)
3560 asMH = Als(mHl, FULLNLO);
3561
3562 mf = Mrun(mHl, mf0, mf0, CHARM, FULLNLO);
3563
3564 beta=1.0-4.0*mf*mf/mHl/mHl;
3565
3566 NF=5;
3567
3568 DeltaQCD = 1 + (asMH/M_PI) * ( 17.0/3.0 + (asMH/M_PI) * ( (35.94 - 1.36*NF) + (164.14 - 25.77*NF + 0.26*NF*NF)*(asMH/M_PI) ) );
3569
3570 Deltamt = (asMH/M_PI) * (asMH/M_PI) * ( 1.57 + (4.0/3.0)*log(mHl/mtpole) + (4.0/9.0) * log(mf/mHl) * log(mf/mHl) );
3571
3572 gamma = Nc * (4.0*GF/sqrt(2.0)) * (mf*mf/16.0/M_PI) * mHl * beta*beta*beta * (DeltaQCD + Deltamt);
3573
3574 return gamma;
3575}

◆ GammaHtogaga()

const double StandardModel::GammaHtogaga ( ) const
virtual

The \(\Gamma(H\to \gamma \gamma)\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
\(\Gamma(H\to \gamma \gamma)\)

Definition at line 3484 of file StandardModel/src/StandardModel.cpp.

3485{
3486 double gamma;
3487
3488 double m_t = mtpole;
3489 double m_b = quarks[BOTTOM].getMass();
3490 double m_c = quarks[CHARM].getMass();
3491 double m_s = quarks[STRANGE].getMass();
3492 double m_tau = leptons[TAU].getMass();
3493 double m_mu = leptons[MU].getMass();
3494
3495 double M_w_2 = pow(Mw(),2.0);
3496
3497 double Qt = quarks[TOP].getCharge();
3498 double Qb = quarks[BOTTOM].getCharge();
3499 double Qc = quarks[CHARM].getCharge();
3500 double Qs = quarks[STRANGE].getCharge();
3501 double Qtau = leptons[TAU].getCharge();
3502 double Qmu = leptons[MU].getCharge();
3503
3504 double tau_t = 4.0 * m_t * m_t / mHl / mHl;
3505 double tau_b = 4.0 * m_b * m_b / mHl / mHl;
3506 double tau_c = 4.0 * m_c * m_c / mHl / mHl;
3507 double tau_s = 4.0 * m_s * m_s / mHl / mHl;
3508 double tau_tau = 4.0 * m_tau * m_tau / mHl / mHl;
3509 double tau_mu = 4.0 * m_mu * m_mu / mHl / mHl;
3510 double tau_W = 4.0 * M_w_2 / mHl / mHl;
3511
3512 gslpp::complex MSM;
3513
3514 MSM = ale * (3.0 * Qt * Qt * AH_f(tau_t) +
3515 3.0 * Qb * Qb * AH_f(tau_b) +
3516 3.0 * Qc * Qc * AH_f(tau_c) +
3517 3.0 * Qs * Qs * AH_f(tau_s) +
3518 Qtau * Qtau * AH_f(tau_tau) +
3519 Qmu * Qmu * AH_f(tau_mu) +
3520 AH_W(tau_W));
3521
3522 gamma = (4.0*GF/sqrt(2)) * (MSM.abs2()) * pow(mHl,3.0)/512.0/pow(M_PI,3);
3523
3524 return gamma;
3525}
gslpp::complex AH_f(const double tau) const
Fermionic loop function entering in the calculation of the effective and couplings.
gslpp::complex AH_W(const double tau) const
W loop function entering in the calculation of the effective coupling.

◆ GammaHtogg()

const double StandardModel::GammaHtogg ( ) const
virtual

The \(\Gamma(H\to gg)\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
\(\Gamma(H\to gg)\)

Definition at line 3361 of file StandardModel/src/StandardModel.cpp.

3362{
3363 double gamma;
3364 double tau_t = 4.0 * pow(quarks[TOP].getMass(),2)/mHl/mHl;
3365 double tau_b = 4.0 * pow(quarks[BOTTOM].getMass(),2)/mHl/mHl;
3366 double tau_c = 4.0 * pow(quarks[CHARM].getMass(),2)/mHl/mHl;
3367 double tau_s = 4.0 * pow(quarks[STRANGE].getMass(),2)/mHl/mHl;
3368 double asMH,LH,Lt,nl,h0,h1,h2, h3,G0;
3369
3370 // alfa_s(MH)
3371 asMH = Als(mHl, FULLNLO);
3372
3373 // NLO corrections ( See https://arxiv.org/pdf/0708.0916 and its REf. [25])
3374 // I only keep up to h3 in expr. (4), and use pole mass in tau factors for the moment
3375 nl = 5;
3376 LH = 0.; // log(mu^2/MH^2) evaluated at mu=MH
3377 Lt = 2.0*log(mHl/(quarks[TOP].getMass()));
3378
3379 h0 = (95./4.) + (11./2.)*LH + nl*(-7./6. - LH/3.);
3380 h1 = 5803./540. + 77.*LH/30. -14.*Lt/15. + nl * (-29./60. - 7. * LH / 45.);
3381 h2 = 1029839./189000. + 16973.*LH/12600. - 1543.*Lt/1575. + nl * ( - 89533./378000 - 1543.*LH/18900. );
3382 h3 = 9075763./2976750. + 1243*LH/1575. - 452.*Lt/575. + nl * ( - 3763./28350. -226. * LH / 4725. );
3383 G0 = GF * pow(mHl,3.0)/(36.*M_PI*sqrt(2.));
3384
3385 gamma = asMH*asMH * (4.0 * GF /sqrt(2.0)) * (mHl*mHl*mHl /64.0/pow(M_PI,3.0)) *
3386 ( AH_f(tau_t) + AH_f(tau_b) + AH_f(tau_c) + AH_f(tau_s) ).abs2()/4.0;
3387
3388 gamma = gamma + G0 * (asMH/M_PI) * (asMH/M_PI) * (asMH/M_PI) * (h0 + h1/tau_t + h2/tau_t/tau_t + h3/tau_t/tau_t/tau_t );
3389
3390 return gamma;
3391}

◆ GammaHtomumu()

const double StandardModel::GammaHtomumu ( ) const
virtual

The \(\Gamma(H\to \mu^+ \mu^-)\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
\(\Gamma(H\to \mu^+ \mu^-)\)

Definition at line 3527 of file StandardModel/src/StandardModel.cpp.

3528{
3529 double mf=leptons[MU].getMass();
3530 double beta=1.0-4.0*mf*mf/mHl/mHl;
3531 double Nc=1.0;
3532 double gamma;
3533
3534 gamma = Nc * (4.0*GF/sqrt(2.0)) * (mf*mf/16.0/M_PI) * mHl * beta*beta*beta;
3535
3536 return gamma;
3537}

◆ GammaHtoss()

const double StandardModel::GammaHtoss ( ) const
virtual

The \(\Gamma(H\to s \bar{s})\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
\(\Gamma(H\to s \bar{s})\)

Definition at line 3577 of file StandardModel/src/StandardModel.cpp.

3578{
3579 double mf0=quarks[STRANGE].getMass(), mf;
3580 double beta;
3581 double Nc=3.0;
3582 double gamma;
3583 double asMH,DeltaQCD,Deltamt,NF;
3584
3585 // alfa_s(MH)
3586 asMH = Als(mHl, FULLNLO);
3587
3588 mf = Mrun(mHl, 2.0, mf0, STRANGE, FULLNLO);
3589
3590 beta=1.0-4.0*mf*mf/mHl/mHl;
3591
3592 NF=5;
3593
3594 DeltaQCD = 1 + (asMH/M_PI) * ( 17.0/3.0 + (asMH/M_PI) * ( (35.94 - 1.36*NF) + (164.14 - 25.77*NF + 0.26*NF*NF)*(asMH/M_PI) ) );
3595
3596 Deltamt = (asMH/M_PI) * (asMH/M_PI) * ( 1.57 + (4.0/3.0)*log(mHl/mtpole) + (4.0/9.0) * log(mf/mHl) * log(mf/mHl) );
3597
3598 gamma = Nc * (4.0*GF/sqrt(2.0)) * (mf*mf/16.0/M_PI) * mHl * beta*beta*beta * (DeltaQCD + Deltamt);
3599
3600 return gamma;
3601}

◆ GammaHTot()

const double StandardModel::GammaHTot ( ) const
virtual

The total Higgs width \(\Gamma(H)\) in the Standard Model.

At the same level of the individual contributions

Returns
\(\Gamma(H)\)

Definition at line 3629 of file StandardModel/src/StandardModel.cpp.

3630{
3631 double gamma;
3632
3633 gamma = GammaHtobb() + GammaHtocc() + GammaHtoss() +
3637
3638 return gamma;
3639}

◆ GammaHtotautau()

const double StandardModel::GammaHtotautau ( ) const
virtual

The \(\Gamma(H\to \tau^+ \tau^-)\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
\(\Gamma(H\to \tau^+ \tau^-)\)

Definition at line 3539 of file StandardModel/src/StandardModel.cpp.

3540{
3541 double mf=leptons[TAU].getMass();
3542 double beta=1.0-4.0*mf*mf/mHl/mHl;
3543 double Nc=1.0;
3544 double gamma;
3545
3546 gamma = Nc * (4.0*GF/sqrt(2.0)) * (mf*mf/16.0/M_PI) * mHl * beta*beta*beta;
3547
3548 return gamma;
3549}

◆ GammaHtoWWstar()

const double StandardModel::GammaHtoWWstar ( ) const
virtual

The \(\Gamma(H\to W W^*)\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
\(\Gamma(H\to W W^*)\)

Definition at line 3409 of file StandardModel/src/StandardModel.cpp.

3410{
3411 double x=Mw()/mHl;
3412 double fx;
3413 double g2 = 4.0 * sqrt(2.0) * GF * pow(Mw(),2);
3414 double gamma;
3415
3416 fx = -fabs(1.0-x*x)*( 47.0*x*x/2.0 - 13.0/2.0 +1.0/x/x ) +
3417 3.0*( 1.0 - 6.0*x*x + 4.0*x*x*x*x )*fabs(log(x)) +
3418 3.0*( 1.0 - 8.0*x*x + 20.0*x*x*x*x )*acos(( 3.0*x*x - 1.0 )/2.0/x/x/x)/sqrt( 4.0*x*x- 1.0);
3419
3420 gamma = 3.0 * g2*g2 * mHl * fx / 512.0 / pow(M_PI,3.0);
3421
3422 return gamma;
3423}

◆ GammaHtoZga()

const double StandardModel::GammaHtoZga ( ) const
virtual

The \(\Gamma(H\to Z \gamma)\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
\(\Gamma(H\to Z \gamma)\)

Definition at line 3425 of file StandardModel/src/StandardModel.cpp.

3426{
3427 double gamma;
3428
3429 double m_t = mtpole;
3430 double m_b = quarks[BOTTOM].getMass();
3431 double m_c = quarks[CHARM].getMass();
3432 double m_s = quarks[STRANGE].getMass();
3433 double m_tau = leptons[TAU].getMass();
3434 double m_mu = leptons[MU].getMass();
3435
3436 double M_w_2 = pow(Mw(),2.0);
3437
3438 double Qt = quarks[TOP].getCharge();
3439 double Qb = quarks[BOTTOM].getCharge();
3440 double Qc = quarks[CHARM].getCharge();
3441 double Qs = quarks[STRANGE].getCharge();
3442 double Qtau = leptons[TAU].getCharge();
3443 double Qmu = leptons[MU].getCharge();
3444
3445 double tau_t = 4.0 * m_t * m_t / mHl / mHl;
3446 double tau_b = 4.0 * m_b * m_b / mHl / mHl;
3447 double tau_c = 4.0 * m_c * m_c / mHl / mHl;
3448 double tau_s = 4.0 * m_s * m_s / mHl / mHl;
3449 double tau_tau = 4.0 * m_tau * m_tau / mHl / mHl;
3450 double tau_mu = 4.0 * m_mu * m_mu / mHl / mHl;
3451 double tau_W = 4.0 * M_w_2 / mHl / mHl;
3452
3453 double lambda_t = 4.0 * m_t * m_t / Mz / Mz;
3454 double lambda_b = 4.0 * m_b * m_b / Mz / Mz;
3455 double lambda_c = 4.0 * m_c * m_c / Mz / Mz;
3456 double lambda_s = 4.0 * m_s * m_s / Mz / Mz;
3457 double lambda_tau = 4.0 * m_tau * m_tau / Mz / Mz;
3458 double lambda_mu = 4.0 * m_mu * m_mu / Mz / Mz;
3459 double lambda_W = 4.0 * M_w_2 / Mz / Mz;
3460
3461 double sc = sqrt(sW2()*cW2());
3462 double vSMt = (2.0 * (quarks[TOP].getIsospin()) - 4.0 * Qt * sW2())/sc;
3463 double vSMb = (2.0 * (quarks[BOTTOM].getIsospin()) - 4.0 * Qb * sW2())/sc;
3464 double vSMc = (2.0 * (quarks[CHARM].getIsospin()) - 4.0 * Qc * sW2())/sc;
3465 double vSMs = (2.0 * (quarks[STRANGE].getIsospin()) - 4.0 * Qs * sW2())/sc;
3466 double vSMtau = (2.0 * (leptons[TAU].getIsospin()) - 4.0 * Qtau * sW2())/sc;
3467 double vSMmu = (2.0 * (leptons[MU].getIsospin()) - 4.0 * Qmu * sW2())/sc;
3468
3469 gslpp::complex MSM;
3470
3471 MSM = (ale/4.0/M_PI) * ((3.0 * vSMt * Qt * AHZga_f(tau_t, lambda_t) +
3472 3.0 * vSMb * Qb * AHZga_f(tau_b, lambda_b) +
3473 3.0 * vSMc * Qc * AHZga_f(tau_c, lambda_c) +
3474 3.0 * vSMs * Qs * AHZga_f(tau_s, lambda_s) +
3475 vSMtau * Qtau * AHZga_f(tau_tau, lambda_tau) +
3476 vSMmu * Qmu * AHZga_f(tau_mu, lambda_mu)) +
3477 AHZga_W(tau_W, lambda_W)/sqrt(sW2()));
3478
3479 gamma = (4.0*sqrt(2)*GF) * (MSM.abs2()) * pow(mHl*(1.0-Mz*Mz/mHl/mHl),3.0)/32.0/M_PI;
3480
3481 return gamma;
3482}
gslpp::complex AHZga_W(const double tau, const double lambda) const
W loop function entering in the calculation of the effective coupling.
gslpp::complex AHZga_f(const double tau, const double lambda) const
Fermionic loop function entering in the calculation of the effective coupling.

◆ GammaHtoZZstar()

const double StandardModel::GammaHtoZZstar ( ) const
virtual

The \(\Gamma(H\to Z Z^*)\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
\(\Gamma(H\to Z Z^*)\)

Definition at line 3393 of file StandardModel/src/StandardModel.cpp.

3394{
3395 double x=Mz/mHl;
3396 double fx;
3397 double g2 = 4.0 * sqrt(2.0) * GF * Mz * Mz;
3398 double gamma;
3399
3400 fx = -fabs(1.0-x*x)*( 47.0*x*x/2.0 - 13.0/2.0 +1.0/x/x ) +
3401 3.0*( 1.0 - 6.0*x*x + 4.0*x*x*x*x )*fabs(log(x)) +
3402 3.0*( 1.0 - 8.0*x*x + 20.0*x*x*x*x )*acos(( 3.0*x*x - 1.0 )/2.0/x/x/x)/sqrt( 4.0*x*x- 1.0);
3403
3404 gamma = g2*g2 * mHl * fx * ( 7.0 - 40.0*sW2()/3.0 + 160.0 *sW2()*sW2()/9.0 ) / 2048.0 / pow(M_PI,3.0);
3405
3406 return gamma;
3407}

◆ GammaW() [1/2]

const double StandardModel::GammaW ( ) const
virtual

The total width of the \(W\) boson, \(\Gamma_W\).

Returns
\(\Gamma_W\) in GeV

Reimplemented in NPbase, NPEpsilons, NPEpsilons_pureNP, NPSMEFTd6, NPSMEFTd6General, NPSTUVWXY, and NPZbbbar.

Definition at line 1265 of file StandardModel/src/StandardModel.cpp.

1266{
1268 if (useGammaW_cache)
1269 return GammaW_cache;
1270
1271 double GammaWtmp = 0.;
1272
1273 for (int i = 0; i < 6; i += 2)
1274 GammaWtmp += GammaW(leptons[i], leptons[i + 1]) + GammaW(quarks[i], quarks[i + 1]);
1275
1276 GammaW_cache = GammaWtmp;
1277 useGammaW_cache = true;
1278 return GammaWtmp;
1279}

◆ GammaW() [2/2]

const double StandardModel::GammaW ( const Particle  fi,
const Particle  fj 
) const
virtual

A partial decay width of the \(W\) boson decay into a SM fermion pair.

\[ \Gamma^W_{ij} = |U_{ij}|^2\,\frac{G_\mu M_W^3}{6\sqrt{2}\,\pi}\,\rho^W_{ij} \]

where \(U\) denotes the MNS matrix, and \(\rho^W_{ij}\) represents EW radiative corrections.

\[ \Gamma^W_{ij} = 3 |V_{ij}|^2\,\frac{G_\mu M_W^3}{6\sqrt{2}\,\pi}\,\rho^W_{ij} \left( 1 + \frac{\alpha_s(M_W^2)}{\pi} \right). \]

where \(V\) denotes the CKM matrix, and \(\rho^W_{ij}\) represents EW radiative corrections.

Parameters
[in]fia lepton or quark
[in]fja lepton or quark
Returns
\(\Gamma^W_{ij}\)
See also
rho_GammaW_l_SM()
Attention
Fermion masses are neglected.

Reimplemented in NPbase, NPSMEFTd6, and NPSMEFTd6General.

Definition at line 1241 of file StandardModel/src/StandardModel.cpp.

1242{
1243 if ((fi.getIndex()) % 2 || (fj.getIndex() + 1) % 2)
1244 throw std::runtime_error("Error in StandardModel::GammaW()");
1245
1246 double G0 = GF * pow(Mw(), 3.0) / 6.0 / sqrt(2.0) / M_PI;
1247 gslpp::complex V(0.0, 0.0, false);
1248
1249 if (fi.is("TOP"))
1250 return (0.0);
1251
1252 if (fj.getIndex() - fi.getIndex() == 1)
1253 V = gslpp::complex(1.0, 0.0, false);
1254 else
1255 V = gslpp::complex(0.0, 0.0, false);
1256
1257 if (fi.is("LEPTON"))
1258 return ( V.abs2() * G0 * rho_GammaW(fi, fj));
1259 else {
1260 double AlsMw = AlsWithInit(Mw(), AlsMz, Mz, 5, FULLNLO);
1261 return ( 3.0 * V.abs2() * G0 * rho_GammaW(fi, fj)*(1.0 + AlsMw / M_PI));
1262 }
1263}
int getIndex() const
Definition: Particle.h:160
virtual const double rho_GammaW(const Particle fi, const Particle fj) const
EW radiative corrections to the width of , denoted as .

◆ GammaZ()

const double StandardModel::GammaZ ( const Particle  f) const
virtual

The \(Z\to \ell\bar{\ell}\) partial decay width, \(\Gamma_\ell\).

When checkNPZff_linearized() returns true and the model flag NoApproximateGammaZ of StandardModel is set to false, this function uses the two-loop approximate formula of \(\Gamma_\ell\) via EWSMApproximateFormulae::X_full_2_loop(). Otherwise, the partial width is calculated with \(\rho_Z^\ell\) and \(g_{V}^\ell/g_{A}^\ell\) [Bardin:1999ak] :

\[ \Gamma_\ell = \Gamma_0 \big|\rho_Z^f\big| \sqrt{1-\frac{4m_\ell^2}{M_Z^2}} \left[ \left(1+\frac{2m_\ell^2}{M_Z^2}\right) \left(\left|\frac{g_{V}^\ell}{g_{A}^\ell}\right|^2 + 1 \right) - \frac{6m_\ell^2}{M_Z^2} \right] \left( 1 + \frac{3}{4}\frac{\alpha(M_Z^2)}{\pi}\, Q_\ell^2 \right) \]

with \(\Gamma_0=G_\mu M_Z^3/(24\sqrt{2}\pi)\).

Parameters
[in]fa lepton or quark
Returns
\(\Gamma_\ell\) in GeV
Attention
\(\ell\) stands for both a neutrino and a charged lepton.

Definition at line 1356 of file StandardModel/src/StandardModel.cpp.

1357{
1358 if (f.is("TOP"))
1359 return 0.0;
1360 double Gamma;
1362
1363 /* SM contribution with the approximate formula */
1364 if (f.is("NEUTRINO_1") || f.is("NEUTRINO_2") || f.is("NEUTRINO_3"))
1365 Gamma = myApproximateFormulae->X_full("Gamma_nu");
1366 else if (f.is("ELECTRON") || f.is("MU"))
1367 Gamma = myApproximateFormulae->X_full("Gamma_e_mu");
1368 else if (f.is("TAU"))
1369 Gamma = myApproximateFormulae->X_full("Gamma_tau");
1370 else if (f.is("UP"))
1371 Gamma = myApproximateFormulae->X_full("Gamma_u");
1372 else if (f.is("CHARM"))
1373 Gamma = myApproximateFormulae->X_full("Gamma_c");
1374 else if (f.is("DOWN") || f.is("STRANGE"))
1375 Gamma = myApproximateFormulae->X_full("Gamma_d_s");
1376 else if (f.is("BOTTOM"))
1377 Gamma = myApproximateFormulae->X_full("Gamma_b");
1378 else
1379 throw std::runtime_error("Error in StandardModel::GammaZ()");
1380
1381 } else {
1382 gslpp::complex myrhoZ_f = rhoZ_f(f);
1383 gslpp::complex gV_over_gA = gV_f(f) / gA_f(f);
1384 double G0 = GF * pow(Mz, 3.0) / 24.0 / sqrt(2.0) / M_PI;
1385 if (f.is("LEPTON")) {
1386 double myalphaMz = alphaMz();
1387 double Q = f.getCharge();
1388 double xl = pow(f.getMass() / Mz, 2.0);
1389 Gamma = G0 * myrhoZ_f.abs() * sqrt(1.0 - 4.0 * xl)
1390 * ((1.0 + 2.0 * xl)*(gV_over_gA.abs2() + 1.0) - 6.0 * xl)
1391 * (1.0 + 3.0 / 4.0 * myalphaMz / M_PI * pow(Q, 2.0));
1392 } else if (f.is("QUARK")) {
1393 Gamma = 3.0 * G0 * myrhoZ_f.abs()*(gV_over_gA.abs2() * RVq((QCD::quark) (f.getIndex() - 6)) + RAq((QCD::quark) (f.getIndex() - 6)));
1394
1395 /* Nonfactorizable EW-QCD corrections */
1396 Gamma += Delta_EWQCD((QCD::quark) (f.getIndex() - 6));
1397 } else
1398 throw std::runtime_error("Error in StandardModel::GammaZ()");
1399 }
1400
1401 return Gamma;
1402}
double Delta_EWQCD(const QCD::quark q) const
The non-factorizable EW-QCD corrections to the partial widths for , denoted as .
double RAq(const QCD::quark q) const
The radiator factor associated with the final-state QED and QCD corrections to the the axial-vector-c...
double RVq(const QCD::quark q) const
The radiator factor associated with the final-state QED and QCD corrections to the the vector-current...
virtual const gslpp::complex gA_f(const Particle f) const
The effective leptonic neutral-current axial-vector coupling in the SM.
virtual const gslpp::complex gV_f(const Particle f) const
The effective leptonic neutral-current vector coupling in the SM.

◆ gAnue()

const double StandardModel::gAnue ( ) const
virtual

The effective (muon) neutrino-electron axial-vector coupling: gAnue.

Follows the corresponding semianalytical expression in EWSMApproximateFormulae.

Returns
\(g_A^{\nu_\mu e}\)

Reimplemented in NPbase.

Definition at line 3067 of file StandardModel/src/StandardModel.cpp.

3068{
3069 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
3071
3072 /* SM contribution with the approximate formula */
3074
3075 } else {
3076 throw std::runtime_error("ERROR: StandardModel::gAnue, prediction implemented only via semianalytical approximate formula. Check flags!");
3077 }
3078}
double LEgAnueApprox() const
The effective (muon) neutrino-electron axial-vector coupling: gAnue.

◆ getAle()

const double StandardModel::getAle ( ) const
inline

A get method to retrieve the fine-structure constant \(\alpha\).

Returns
\(\alpha\)

Definition at line 789 of file StandardModel.h.

790 {
791 return ale;
792 }

◆ getAlsMz()

const double StandardModel::getAlsMz ( ) const
inline

A get method to access the value of \(\alpha_s(M_Z)\).

Returns
the strong coupling constant at \(M_Z\), \(\alpha_s(M_Z)\)

Definition at line 771 of file StandardModel.h.

772 {
773 return AlsMz;
774 }

◆ getCBd()

virtual const double StandardModel::getCBd ( ) const
inlinevirtual

The ratio of the absolute value of the $B_d$ mixing amplitude over the Standard Model value.

Returns
\(\vert (M_{12}^{bd})_\mathrm{full}/(M_{12}^{bd})_\mathrm{SM}\vert\)

Reimplemented in NPDF2.

Definition at line 3066 of file StandardModel.h.

3067 {
3068 return 1.;
3069 }

◆ getCBs()

virtual const double StandardModel::getCBs ( ) const
inlinevirtual

The ratio of the absolute value of the $B_s$ mixing amplitude over the Standard Model value.

Returns
\(\vert (M_{12}^{bs})_\mathrm{full}/(M_{12}^{bs})_\mathrm{SM}\vert\)

Reimplemented in NPDF2.

Definition at line 3075 of file StandardModel.h.

3076 {
3077 return 1.;
3078 }

◆ getCCC1()

virtual const double StandardModel::getCCC1 ( ) const
inlinevirtual

A virtual implementation for the RealWeakEFTCC class.

Reimplemented in RealWeakEFTCC.

Definition at line 1173 of file StandardModel.h.

1173{ return 0.; };

◆ getCCC2()

virtual const double StandardModel::getCCC2 ( ) const
inlinevirtual

A virtual implementation for the RealWeakEFTCC class.

Reimplemented in RealWeakEFTCC.

Definition at line 1178 of file StandardModel.h.

1178{ return 0.; };

◆ getCCC3()

virtual const double StandardModel::getCCC3 ( ) const
inlinevirtual

A virtual implementation for the RealWeakEFTCC class.

Reimplemented in RealWeakEFTCC.

Definition at line 1183 of file StandardModel.h.

1183{ return 0.; };

◆ getCCC4()

virtual const double StandardModel::getCCC4 ( ) const
inlinevirtual

A virtual implementation for the RealWeakEFTCC class.

Definition at line 1188 of file StandardModel.h.

1188{ return 0.; };

◆ getCCC5()

virtual const double StandardModel::getCCC5 ( ) const
inlinevirtual

A virtual implementation for the RealWeakEFTCC class.

Definition at line 1193 of file StandardModel.h.

1193{ return 0.; };

◆ getCDMK()

virtual const double StandardModel::getCDMK ( ) const
inlinevirtual

The ratio of the real part of the $K$ mixing amplitude over the Standard Model value.

Returns
\((\mathrm{Re} M_{12}^{sd})_\mathrm{full}/(\mathrm{Re} M_{12}^{sd})_\mathrm{SM}\vert\)

Reimplemented in NPDF2.

Definition at line 3084 of file StandardModel.h.

3085 {
3086 return 1.;
3087 }

◆ getCepsK()

virtual const double StandardModel::getCepsK ( ) const
inlinevirtual

The ratio of the imaginary part of the $K$ mixing amplitude over the Standard Model value.

Returns
\((\mathrm{Im} M_{12}^{sd})_\mathrm{full}/(\mathrm{Im} M_{12}^{sd})_\mathrm{SM}\vert\)

Reimplemented in NPDF2.

Definition at line 3093 of file StandardModel.h.

3094 {
3095 return 1.;
3096 }

◆ getCKM()

const CKM & StandardModel::getCKM ( ) const
inline

A get method to retrieve the member object of type CKM.

Returns
a reference to the object of type CKM

Definition at line 920 of file StandardModel.h.

921 {
922 return myCKM;
923 }

◆ getDAle5Mz()

const double StandardModel::getDAle5Mz ( ) const
inline

A get method to retrieve the five-flavour hadronic contribution to the electromagnetic coupling, \(\Delta\alpha_{\mathrm{had}}^{(5)}(M_Z^2)\).

Returns
\(\Delta\alpha_{\mathrm{had}}^{(5)}(M_Z^2)\)

Definition at line 800 of file StandardModel.h.

801 {
802 return dAle5Mz;
803 }

◆ getDelGammaZ()

const double StandardModel::getDelGammaZ ( ) const
inline

A get method to retrieve the theoretical uncertainty in \(\Gamma_Z\), denoted as \(\delta\,\Gamma_Z\).

Returns
\(\delta\,\Gamma_Z\) in GeV

Definition at line 862 of file StandardModel.h.

863 {
864 return delGammaZ;
865 }

◆ getDelMw()

const double StandardModel::getDelMw ( ) const
inline

A get method to retrieve the theoretical uncertainty in \(M_W\), denoted as \(\delta\,M_W\).

Returns
\(\delta\,M_W\) in GeV

Definition at line 819 of file StandardModel.h.

820 {
821 return delMw;
822 }

◆ getDelR0b()

const double StandardModel::getDelR0b ( ) const
inline

A get method to retrieve the theoretical uncertainty in \(R_b^0\), denoted as \(\delta\,R_b^0\).

Returns
\(\delta\,R_b^0\)

Definition at line 902 of file StandardModel.h.

903 {
904 return delR0b;
905 }

◆ getDelR0c()

const double StandardModel::getDelR0c ( ) const
inline

A get method to retrieve the theoretical uncertainty in \(R_c^0\), denoted as \(\delta\,R_c^0\).

Returns
\(\delta\,R_c^0\)

Definition at line 892 of file StandardModel.h.

893 {
894 return delR0c;
895 }

◆ getDelR0l()

const double StandardModel::getDelR0l ( ) const
inline

A get method to retrieve the theoretical uncertainty in \(R_l^0\), denoted as \(\delta\,R_l^0\).

Returns
\(\delta\,R_l^0\)

Definition at line 882 of file StandardModel.h.

883 {
884 return delR0l;
885 }

◆ getDelSigma0H()

const double StandardModel::getDelSigma0H ( ) const
inline

A get method to retrieve the theoretical uncertainty in \(\sigma_{Hadron}^0\), denoted as \(\delta\,\sigma_{Hadron}^0\).

Returns
\(\delta\,\sigma_{Hadron}^0\) in nb

Definition at line 872 of file StandardModel.h.

873 {
874 return delsigma0H;
875 }

◆ getDelSin2th_b()

const double StandardModel::getDelSin2th_b ( ) const
inline

A get method to retrieve the theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{b}\), denoted as \(\delta\sin^2\theta_{\rm eff}^{b}\).

Returns
\(\delta\sin^2\theta_{\rm eff}^{b}\)

Definition at line 852 of file StandardModel.h.

853 {
854 return delSin2th_b;
855 }

◆ getDelSin2th_l()

const double StandardModel::getDelSin2th_l ( ) const
inline

A get method to retrieve the theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{\rm lept}\), denoted as \(\delta\sin^2\theta_{\rm eff}^{\rm lept}\).

Returns
\(\delta\sin^2\theta_{\rm eff}^{\rm lept}\)

Definition at line 830 of file StandardModel.h.

831 {
832 return delSin2th_l;
833 }

◆ getDelSin2th_q()

const double StandardModel::getDelSin2th_q ( ) const
inline

A get method to retrieve the theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{q\not = b,t}\), denoted as \(\delta\sin^2\theta_{\rm eff}^{q\not = b,t}\).

Returns
\(\delta\sin^2\theta_{\rm eff}^{q\not = b,t}\)

Definition at line 841 of file StandardModel.h.

842 {
843 return delSin2th_q;
844 }

◆ getFlagKappaZ()

const std::string StandardModel::getFlagKappaZ ( ) const
inline

A method to retrieve the model flag KappaZ.

See StandardModelFlags for detail.

Returns

Definition at line 714 of file StandardModel.h.

715 {
716 return FlagKappaZ;
717 }

◆ getFlagMw()

const std::string StandardModel::getFlagMw ( ) const
inline

A method to retrieve the model flag Mw.

See StandardModelFlags for detail.

Returns

Definition at line 694 of file StandardModel.h.

695 {
696 return FlagMw;
697 }

◆ getFlagRhoZ()

const std::string StandardModel::getFlagRhoZ ( ) const
inline

A method to retrieve the model flag RhoZ.

See StandardModelFlags for detail.

Returns

Definition at line 704 of file StandardModel.h.

705 {
706 return FlagRhoZ;
707 }

◆ getFlavour()

const Flavour & StandardModel::getFlavour ( ) const
inline

Definition at line 1033 of file StandardModel.h.

1034 {
1035 return SMFlavour;
1036 }

◆ getGF()

const double StandardModel::getGF ( ) const
inline

A get method to retrieve the Fermi constant \(G_\mu\).

Returns
\(G_\mu\) in \({\rm GeV}^{-2}\)

Definition at line 780 of file StandardModel.h.

781 {
782 return GF;
783 }

◆ getIntegrand_AFBnumeratorWithISR_bottom133()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom133 ( double  x) const
protected

Definition at line 9533 of file StandardModel/src/StandardModel.cpp.

9534{
9535 double s = 133. * 133.;
9537}
const double Integrand_AFBnumeratorWithISR_q(double x, const QCD::quark q_flavor, const double s) const

◆ getIntegrand_AFBnumeratorWithISR_bottom167()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom167 ( double  x) const
protected

Definition at line 9539 of file StandardModel/src/StandardModel.cpp.

9540{
9541 double s = 167. * 167.;
9543}

◆ getIntegrand_AFBnumeratorWithISR_bottom172()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom172 ( double  x) const
protected

Definition at line 9545 of file StandardModel/src/StandardModel.cpp.

9546{
9547 double s = 172. * 172.;
9549}

◆ getIntegrand_AFBnumeratorWithISR_bottom183()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom183 ( double  x) const
protected

Definition at line 9551 of file StandardModel/src/StandardModel.cpp.

9552{
9553 double s = 183. * 183.;
9555}

◆ getIntegrand_AFBnumeratorWithISR_bottom189()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom189 ( double  x) const
protected

Definition at line 9557 of file StandardModel/src/StandardModel.cpp.

9558{
9559 double s = 189. * 189.;
9561}

◆ getIntegrand_AFBnumeratorWithISR_bottom192()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom192 ( double  x) const
protected

Definition at line 9563 of file StandardModel/src/StandardModel.cpp.

9564{
9565 double s = 192. * 192.;
9567}

◆ getIntegrand_AFBnumeratorWithISR_bottom196()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom196 ( double  x) const
protected

Definition at line 9569 of file StandardModel/src/StandardModel.cpp.

9570{
9571 double s = 196. * 196.;
9573}

◆ getIntegrand_AFBnumeratorWithISR_bottom200()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom200 ( double  x) const
protected

Definition at line 9575 of file StandardModel/src/StandardModel.cpp.

9576{
9577 double s = 200. * 200.;
9579}

◆ getIntegrand_AFBnumeratorWithISR_bottom202()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom202 ( double  x) const
protected

Definition at line 9581 of file StandardModel/src/StandardModel.cpp.

9582{
9583 double s = 202. * 202.;
9585}

◆ getIntegrand_AFBnumeratorWithISR_bottom205()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom205 ( double  x) const
protected

Definition at line 9587 of file StandardModel/src/StandardModel.cpp.

9588{
9589 double s = 205. * 205.;
9591}

◆ getIntegrand_AFBnumeratorWithISR_bottom207()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom207 ( double  x) const
protected

Definition at line 9593 of file StandardModel/src/StandardModel.cpp.

9594{
9595 double s = 207. * 207.;
9597}

◆ getIntegrand_AFBnumeratorWithISR_charm133()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm133 ( double  x) const
protected

Definition at line 9464 of file StandardModel/src/StandardModel.cpp.

9465{
9466 double s = 133. * 133.;
9468}

◆ getIntegrand_AFBnumeratorWithISR_charm167()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm167 ( double  x) const
protected

Definition at line 9470 of file StandardModel/src/StandardModel.cpp.

9471{
9472 double s = 167. * 167.;
9474}

◆ getIntegrand_AFBnumeratorWithISR_charm172()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm172 ( double  x) const
protected

Definition at line 9476 of file StandardModel/src/StandardModel.cpp.

9477{
9478 double s = 172. * 172.;
9480}

◆ getIntegrand_AFBnumeratorWithISR_charm183()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm183 ( double  x) const
protected

Definition at line 9482 of file StandardModel/src/StandardModel.cpp.

9483{
9484 double s = 183. * 183.;
9486}

◆ getIntegrand_AFBnumeratorWithISR_charm189()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm189 ( double  x) const
protected

Definition at line 9488 of file StandardModel/src/StandardModel.cpp.

9489{
9490 double s = 189. * 189.;
9492}

◆ getIntegrand_AFBnumeratorWithISR_charm192()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm192 ( double  x) const
protected

Definition at line 9494 of file StandardModel/src/StandardModel.cpp.

9495{
9496 double s = 192. * 192.;
9498}

◆ getIntegrand_AFBnumeratorWithISR_charm196()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm196 ( double  x) const
protected

Definition at line 9500 of file StandardModel/src/StandardModel.cpp.

9501{
9502 double s = 196. * 196.;
9504}

◆ getIntegrand_AFBnumeratorWithISR_charm200()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm200 ( double  x) const
protected

Definition at line 9506 of file StandardModel/src/StandardModel.cpp.

9507{
9508 double s = 200. * 200.;
9510}

◆ getIntegrand_AFBnumeratorWithISR_charm202()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm202 ( double  x) const
protected

Definition at line 9512 of file StandardModel/src/StandardModel.cpp.

9513{
9514 double s = 202. * 202.;
9516}

◆ getIntegrand_AFBnumeratorWithISR_charm205()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm205 ( double  x) const
protected

Definition at line 9518 of file StandardModel/src/StandardModel.cpp.

9519{
9520 double s = 205. * 205.;
9522}

◆ getIntegrand_AFBnumeratorWithISR_charm207()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm207 ( double  x) const
protected

Definition at line 9524 of file StandardModel/src/StandardModel.cpp.

9525{
9526 double s = 207. * 207.;
9528}

◆ getIntegrand_AFBnumeratorWithISR_mu130()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu130 ( double  x) const
protected

Definition at line 9302 of file StandardModel/src/StandardModel.cpp.

9303{
9304 double s = 130. * 130.;
9306}
lepton
An enum type for leptons.
Definition: QCD.h:310
const double Integrand_AFBnumeratorWithISR_l(double x, const QCD::lepton l_flavor, const double s) const

◆ getIntegrand_AFBnumeratorWithISR_mu136()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu136 ( double  x) const
protected

Definition at line 9308 of file StandardModel/src/StandardModel.cpp.

9309{
9310 double s = 136. * 136.;
9312}

◆ getIntegrand_AFBnumeratorWithISR_mu161()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu161 ( double  x) const
protected

Definition at line 9314 of file StandardModel/src/StandardModel.cpp.

9315{
9316 double s = 161. * 161.;
9318}

◆ getIntegrand_AFBnumeratorWithISR_mu172()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu172 ( double  x) const
protected

Definition at line 9320 of file StandardModel/src/StandardModel.cpp.

9321{
9322 double s = 172. * 172.;
9324}

◆ getIntegrand_AFBnumeratorWithISR_mu183()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu183 ( double  x) const
protected

Definition at line 9326 of file StandardModel/src/StandardModel.cpp.

9327{
9328 double s = 183. * 183.;
9330}

◆ getIntegrand_AFBnumeratorWithISR_mu189()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu189 ( double  x) const
protected

Definition at line 9332 of file StandardModel/src/StandardModel.cpp.

9333{
9334 double s = 189. * 189.;
9336}

◆ getIntegrand_AFBnumeratorWithISR_mu192()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu192 ( double  x) const
protected

Definition at line 9338 of file StandardModel/src/StandardModel.cpp.

9339{
9340 double s = 192. * 192.;
9342}

◆ getIntegrand_AFBnumeratorWithISR_mu196()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu196 ( double  x) const
protected

Definition at line 9344 of file StandardModel/src/StandardModel.cpp.

9345{
9346 double s = 196. * 196.;
9348}

◆ getIntegrand_AFBnumeratorWithISR_mu200()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu200 ( double  x) const
protected

Definition at line 9350 of file StandardModel/src/StandardModel.cpp.

9351{
9352 double s = 200. * 200.;
9354}

◆ getIntegrand_AFBnumeratorWithISR_mu202()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu202 ( double  x) const
protected

Definition at line 9356 of file StandardModel/src/StandardModel.cpp.

9357{
9358 double s = 202. * 202.;
9360}

◆ getIntegrand_AFBnumeratorWithISR_mu205()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu205 ( double  x) const
protected

Definition at line 9362 of file StandardModel/src/StandardModel.cpp.

9363{
9364 double s = 205. * 205.;
9366}

◆ getIntegrand_AFBnumeratorWithISR_mu207()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu207 ( double  x) const
protected

Definition at line 9368 of file StandardModel/src/StandardModel.cpp.

9369{
9370 double s = 207. * 207.;
9372}

◆ getIntegrand_AFBnumeratorWithISR_tau130()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau130 ( double  x) const
protected

Definition at line 9375 of file StandardModel/src/StandardModel.cpp.

9376{
9377 double s = 130. * 130.;
9379}

◆ getIntegrand_AFBnumeratorWithISR_tau136()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau136 ( double  x) const
protected

Definition at line 9381 of file StandardModel/src/StandardModel.cpp.

9382{
9383 double s = 136. * 136.;
9385}

◆ getIntegrand_AFBnumeratorWithISR_tau161()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau161 ( double  x) const
protected

Definition at line 9387 of file StandardModel/src/StandardModel.cpp.

9388{
9389 double s = 161. * 161.;
9391}

◆ getIntegrand_AFBnumeratorWithISR_tau172()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau172 ( double  x) const
protected

Definition at line 9393 of file StandardModel/src/StandardModel.cpp.

9394{
9395 double s = 172. * 172.;
9397}

◆ getIntegrand_AFBnumeratorWithISR_tau183()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau183 ( double  x) const
protected

Definition at line 9399 of file StandardModel/src/StandardModel.cpp.

9400{
9401 double s = 183. * 183.;
9403}

◆ getIntegrand_AFBnumeratorWithISR_tau189()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau189 ( double  x) const
protected

Definition at line 9405 of file StandardModel/src/StandardModel.cpp.

9406{
9407 double s = 189. * 189.;
9409}

◆ getIntegrand_AFBnumeratorWithISR_tau192()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau192 ( double  x) const
protected

Definition at line 9411 of file StandardModel/src/StandardModel.cpp.

9412{
9413 double s = 192. * 192.;
9415}

◆ getIntegrand_AFBnumeratorWithISR_tau196()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau196 ( double  x) const
protected

Definition at line 9417 of file StandardModel/src/StandardModel.cpp.

9418{
9419 double s = 196. * 196.;
9421}

◆ getIntegrand_AFBnumeratorWithISR_tau200()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau200 ( double  x) const
protected

Definition at line 9423 of file StandardModel/src/StandardModel.cpp.

9424{
9425 double s = 200. * 200.;
9427}

◆ getIntegrand_AFBnumeratorWithISR_tau202()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau202 ( double  x) const
protected

Definition at line 9429 of file StandardModel/src/StandardModel.cpp.

9430{
9431 double s = 202. * 202.;
9433}

◆ getIntegrand_AFBnumeratorWithISR_tau205()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau205 ( double  x) const
protected

Definition at line 9435 of file StandardModel/src/StandardModel.cpp.

9436{
9437 double s = 205. * 205.;
9439}

◆ getIntegrand_AFBnumeratorWithISR_tau207()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau207 ( double  x) const
protected

Definition at line 9441 of file StandardModel/src/StandardModel.cpp.

9442{
9443 double s = 207. * 207.;
9445}

◆ getIntegrand_dsigmaBox_bottom130()

const double StandardModel::getIntegrand_dsigmaBox_bottom130 ( double  x) const
protected

Definition at line 9194 of file StandardModel/src/StandardModel.cpp.

9195{
9196 double s = 130. * 130.;
9198}
const double Integrand_dsigmaBox_q(double cosTheta, const QCD::quark q_flavor, const double s) const

◆ getIntegrand_dsigmaBox_bottom133()

const double StandardModel::getIntegrand_dsigmaBox_bottom133 ( double  x) const
protected

Definition at line 9200 of file StandardModel/src/StandardModel.cpp.

9201{
9202 double s = 133. * 133.;
9204}

◆ getIntegrand_dsigmaBox_bottom136()

const double StandardModel::getIntegrand_dsigmaBox_bottom136 ( double  x) const
protected

Definition at line 9206 of file StandardModel/src/StandardModel.cpp.

9207{
9208 double s = 136. * 136.;
9210}

◆ getIntegrand_dsigmaBox_bottom161()

const double StandardModel::getIntegrand_dsigmaBox_bottom161 ( double  x) const
protected

Definition at line 9212 of file StandardModel/src/StandardModel.cpp.

9213{
9214 double s = 161. * 161.;
9216}

◆ getIntegrand_dsigmaBox_bottom167()

const double StandardModel::getIntegrand_dsigmaBox_bottom167 ( double  x) const
protected

Definition at line 9218 of file StandardModel/src/StandardModel.cpp.

9219{
9220 double s = 167. * 167.;
9222}

◆ getIntegrand_dsigmaBox_bottom172()

const double StandardModel::getIntegrand_dsigmaBox_bottom172 ( double  x) const
protected

Definition at line 9224 of file StandardModel/src/StandardModel.cpp.

9225{
9226 double s = 172. * 172.;
9228}

◆ getIntegrand_dsigmaBox_bottom183()

const double StandardModel::getIntegrand_dsigmaBox_bottom183 ( double  x) const
protected

Definition at line 9230 of file StandardModel/src/StandardModel.cpp.

9231{
9232 double s = 183. * 183.;
9234}

◆ getIntegrand_dsigmaBox_bottom189()

const double StandardModel::getIntegrand_dsigmaBox_bottom189 ( double  x) const
protected

Definition at line 9236 of file StandardModel/src/StandardModel.cpp.

9237{
9238 double s = 189. * 189.;
9240}

◆ getIntegrand_dsigmaBox_bottom192()

const double StandardModel::getIntegrand_dsigmaBox_bottom192 ( double  x) const
protected

Definition at line 9242 of file StandardModel/src/StandardModel.cpp.

9243{
9244 double s = 192. * 192.;
9246}

◆ getIntegrand_dsigmaBox_bottom196()

const double StandardModel::getIntegrand_dsigmaBox_bottom196 ( double  x) const
protected

Definition at line 9248 of file StandardModel/src/StandardModel.cpp.

9249{
9250 double s = 196. * 196.;
9252}

◆ getIntegrand_dsigmaBox_bottom200()

const double StandardModel::getIntegrand_dsigmaBox_bottom200 ( double  x) const
protected

Definition at line 9254 of file StandardModel/src/StandardModel.cpp.

9255{
9256 double s = 200. * 200.;
9258}

◆ getIntegrand_dsigmaBox_bottom202()

const double StandardModel::getIntegrand_dsigmaBox_bottom202 ( double  x) const
protected

Definition at line 9260 of file StandardModel/src/StandardModel.cpp.

9261{
9262 double s = 202. * 202.;
9264}

◆ getIntegrand_dsigmaBox_bottom205()

const double StandardModel::getIntegrand_dsigmaBox_bottom205 ( double  x) const
protected

Definition at line 9266 of file StandardModel/src/StandardModel.cpp.

9267{
9268 double s = 205. * 205.;
9270}

◆ getIntegrand_dsigmaBox_bottom207()

const double StandardModel::getIntegrand_dsigmaBox_bottom207 ( double  x) const
protected

Definition at line 9272 of file StandardModel/src/StandardModel.cpp.

9273{
9274 double s = 207. * 207.;
9276}

◆ getIntegrand_dsigmaBox_charm130()

const double StandardModel::getIntegrand_dsigmaBox_charm130 ( double  x) const
protected

Definition at line 9016 of file StandardModel/src/StandardModel.cpp.

9017{
9018 double s = 130. * 130.;
9019 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9020}

◆ getIntegrand_dsigmaBox_charm133()

const double StandardModel::getIntegrand_dsigmaBox_charm133 ( double  x) const
protected

Definition at line 9022 of file StandardModel/src/StandardModel.cpp.

9023{
9024 double s = 133. * 133.;
9025 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9026}

◆ getIntegrand_dsigmaBox_charm136()

const double StandardModel::getIntegrand_dsigmaBox_charm136 ( double  x) const
protected

Definition at line 9028 of file StandardModel/src/StandardModel.cpp.

9029{
9030 double s = 136. * 136.;
9031 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9032}

◆ getIntegrand_dsigmaBox_charm161()

const double StandardModel::getIntegrand_dsigmaBox_charm161 ( double  x) const
protected

Definition at line 9034 of file StandardModel/src/StandardModel.cpp.

9035{
9036 double s = 161. * 161.;
9037 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9038}

◆ getIntegrand_dsigmaBox_charm167()

const double StandardModel::getIntegrand_dsigmaBox_charm167 ( double  x) const
protected

Definition at line 9040 of file StandardModel/src/StandardModel.cpp.

9041{
9042 double s = 167. * 167.;
9043 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9044}

◆ getIntegrand_dsigmaBox_charm172()

const double StandardModel::getIntegrand_dsigmaBox_charm172 ( double  x) const
protected

Definition at line 9046 of file StandardModel/src/StandardModel.cpp.

9047{
9048 double s = 172. * 172.;
9049 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9050}

◆ getIntegrand_dsigmaBox_charm183()

const double StandardModel::getIntegrand_dsigmaBox_charm183 ( double  x) const
protected

Definition at line 9052 of file StandardModel/src/StandardModel.cpp.

9053{
9054 double s = 183. * 183.;
9055 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9056}

◆ getIntegrand_dsigmaBox_charm189()

const double StandardModel::getIntegrand_dsigmaBox_charm189 ( double  x) const
protected

Definition at line 9058 of file StandardModel/src/StandardModel.cpp.

9059{
9060 double s = 189. * 189.;
9061 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9062}

◆ getIntegrand_dsigmaBox_charm192()

const double StandardModel::getIntegrand_dsigmaBox_charm192 ( double  x) const
protected

Definition at line 9064 of file StandardModel/src/StandardModel.cpp.

9065{
9066 double s = 192. * 192.;
9067 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9068}

◆ getIntegrand_dsigmaBox_charm196()

const double StandardModel::getIntegrand_dsigmaBox_charm196 ( double  x) const
protected

Definition at line 9070 of file StandardModel/src/StandardModel.cpp.

9071{
9072 double s = 196. * 196.;
9073 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9074}

◆ getIntegrand_dsigmaBox_charm200()

const double StandardModel::getIntegrand_dsigmaBox_charm200 ( double  x) const
protected

Definition at line 9076 of file StandardModel/src/StandardModel.cpp.

9077{
9078 double s = 200. * 200.;
9079 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9080}

◆ getIntegrand_dsigmaBox_charm202()

const double StandardModel::getIntegrand_dsigmaBox_charm202 ( double  x) const
protected

Definition at line 9082 of file StandardModel/src/StandardModel.cpp.

9083{
9084 double s = 202. * 202.;
9085 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9086}

◆ getIntegrand_dsigmaBox_charm205()

const double StandardModel::getIntegrand_dsigmaBox_charm205 ( double  x) const
protected

Definition at line 9088 of file StandardModel/src/StandardModel.cpp.

9089{
9090 double s = 205. * 205.;
9091 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9092}

◆ getIntegrand_dsigmaBox_charm207()

const double StandardModel::getIntegrand_dsigmaBox_charm207 ( double  x) const
protected

Definition at line 9094 of file StandardModel/src/StandardModel.cpp.

9095{
9096 double s = 207. * 207.;
9097 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9098}

◆ getIntegrand_dsigmaBox_down130()

const double StandardModel::getIntegrand_dsigmaBox_down130 ( double  x) const
protected

Definition at line 8928 of file StandardModel/src/StandardModel.cpp.

8929{
8930 double s = 130. * 130.;
8931 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8932}

◆ getIntegrand_dsigmaBox_down133()

const double StandardModel::getIntegrand_dsigmaBox_down133 ( double  x) const
protected

Definition at line 8934 of file StandardModel/src/StandardModel.cpp.

8935{
8936 double s = 133. * 133.;
8937 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8938}

◆ getIntegrand_dsigmaBox_down136()

const double StandardModel::getIntegrand_dsigmaBox_down136 ( double  x) const
protected

Definition at line 8940 of file StandardModel/src/StandardModel.cpp.

8941{
8942 double s = 136. * 136.;
8943 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8944}

◆ getIntegrand_dsigmaBox_down161()

const double StandardModel::getIntegrand_dsigmaBox_down161 ( double  x) const
protected

Definition at line 8946 of file StandardModel/src/StandardModel.cpp.

8947{
8948 double s = 161. * 161.;
8949 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8950}

◆ getIntegrand_dsigmaBox_down167()

const double StandardModel::getIntegrand_dsigmaBox_down167 ( double  x) const
protected

Definition at line 8952 of file StandardModel/src/StandardModel.cpp.

8953{
8954 double s = 167. * 167.;
8955 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8956}

◆ getIntegrand_dsigmaBox_down172()

const double StandardModel::getIntegrand_dsigmaBox_down172 ( double  x) const
protected

Definition at line 8958 of file StandardModel/src/StandardModel.cpp.

8959{
8960 double s = 172. * 172.;
8961 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8962}

◆ getIntegrand_dsigmaBox_down183()

const double StandardModel::getIntegrand_dsigmaBox_down183 ( double  x) const
protected

Definition at line 8964 of file StandardModel/src/StandardModel.cpp.

8965{
8966 double s = 183. * 183.;
8967 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8968}

◆ getIntegrand_dsigmaBox_down189()

const double StandardModel::getIntegrand_dsigmaBox_down189 ( double  x) const
protected

Definition at line 8970 of file StandardModel/src/StandardModel.cpp.

8971{
8972 double s = 189. * 189.;
8973 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8974}

◆ getIntegrand_dsigmaBox_down192()

const double StandardModel::getIntegrand_dsigmaBox_down192 ( double  x) const
protected

Definition at line 8976 of file StandardModel/src/StandardModel.cpp.

8977{
8978 double s = 192. * 192.;
8979 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8980}

◆ getIntegrand_dsigmaBox_down196()

const double StandardModel::getIntegrand_dsigmaBox_down196 ( double  x) const
protected

Definition at line 8982 of file StandardModel/src/StandardModel.cpp.

8983{
8984 double s = 196. * 196.;
8985 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8986}

◆ getIntegrand_dsigmaBox_down200()

const double StandardModel::getIntegrand_dsigmaBox_down200 ( double  x) const
protected

Definition at line 8988 of file StandardModel/src/StandardModel.cpp.

8989{
8990 double s = 200. * 200.;
8991 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8992}

◆ getIntegrand_dsigmaBox_down202()

const double StandardModel::getIntegrand_dsigmaBox_down202 ( double  x) const
protected

Definition at line 8994 of file StandardModel/src/StandardModel.cpp.

8995{
8996 double s = 202. * 202.;
8997 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8998}

◆ getIntegrand_dsigmaBox_down205()

const double StandardModel::getIntegrand_dsigmaBox_down205 ( double  x) const
protected

Definition at line 9000 of file StandardModel/src/StandardModel.cpp.

9001{
9002 double s = 205. * 205.;
9003 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
9004}

◆ getIntegrand_dsigmaBox_down207()

const double StandardModel::getIntegrand_dsigmaBox_down207 ( double  x) const
protected

Definition at line 9006 of file StandardModel/src/StandardModel.cpp.

9007{
9008 double s = 207. * 207.;
9009 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
9010}

◆ getIntegrand_dsigmaBox_mu130()

const double StandardModel::getIntegrand_dsigmaBox_mu130 ( double  x) const
protected

Definition at line 8676 of file StandardModel/src/StandardModel.cpp.

8677{
8678 double s = 130. * 130.;
8679 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8680}
const double Integrand_dsigmaBox_l(double cosTheta, const QCD::lepton l_flavor, const double s) const

◆ getIntegrand_dsigmaBox_mu133()

const double StandardModel::getIntegrand_dsigmaBox_mu133 ( double  x) const
protected

◆ getIntegrand_dsigmaBox_mu136()

const double StandardModel::getIntegrand_dsigmaBox_mu136 ( double  x) const
protected

Definition at line 8682 of file StandardModel/src/StandardModel.cpp.

8683{
8684 double s = 136. * 136.;
8685 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8686}

◆ getIntegrand_dsigmaBox_mu161()

const double StandardModel::getIntegrand_dsigmaBox_mu161 ( double  x) const
protected

Definition at line 8688 of file StandardModel/src/StandardModel.cpp.

8689{
8690 double s = 161. * 161.;
8691 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8692}

◆ getIntegrand_dsigmaBox_mu167()

const double StandardModel::getIntegrand_dsigmaBox_mu167 ( double  x) const
protected

◆ getIntegrand_dsigmaBox_mu172()

const double StandardModel::getIntegrand_dsigmaBox_mu172 ( double  x) const
protected

Definition at line 8694 of file StandardModel/src/StandardModel.cpp.

8695{
8696 double s = 172. * 172.;
8697 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8698}

◆ getIntegrand_dsigmaBox_mu183()

const double StandardModel::getIntegrand_dsigmaBox_mu183 ( double  x) const
protected

Definition at line 8700 of file StandardModel/src/StandardModel.cpp.

8701{
8702 double s = 183. * 183.;
8703 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8704}

◆ getIntegrand_dsigmaBox_mu189()

const double StandardModel::getIntegrand_dsigmaBox_mu189 ( double  x) const
protected

Definition at line 8706 of file StandardModel/src/StandardModel.cpp.

8707{
8708 double s = 189. * 189.;
8709 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8710}

◆ getIntegrand_dsigmaBox_mu192()

const double StandardModel::getIntegrand_dsigmaBox_mu192 ( double  x) const
protected

Definition at line 8712 of file StandardModel/src/StandardModel.cpp.

8713{
8714 double s = 192. * 192.;
8715 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8716}

◆ getIntegrand_dsigmaBox_mu196()

const double StandardModel::getIntegrand_dsigmaBox_mu196 ( double  x) const
protected

Definition at line 8718 of file StandardModel/src/StandardModel.cpp.

8719{
8720 double s = 196. * 196.;
8721 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8722}

◆ getIntegrand_dsigmaBox_mu200()

const double StandardModel::getIntegrand_dsigmaBox_mu200 ( double  x) const
protected

Definition at line 8724 of file StandardModel/src/StandardModel.cpp.

8725{
8726 double s = 200. * 200.;
8727 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8728}

◆ getIntegrand_dsigmaBox_mu202()

const double StandardModel::getIntegrand_dsigmaBox_mu202 ( double  x) const
protected

Definition at line 8730 of file StandardModel/src/StandardModel.cpp.

8731{
8732 double s = 202. * 202.;
8733 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8734}

◆ getIntegrand_dsigmaBox_mu205()

const double StandardModel::getIntegrand_dsigmaBox_mu205 ( double  x) const
protected

Definition at line 8736 of file StandardModel/src/StandardModel.cpp.

8737{
8738 double s = 205. * 205.;
8739 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8740}

◆ getIntegrand_dsigmaBox_mu207()

const double StandardModel::getIntegrand_dsigmaBox_mu207 ( double  x) const
protected

Definition at line 8742 of file StandardModel/src/StandardModel.cpp.

8743{
8744 double s = 207. * 207.;
8745 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8746}

◆ getIntegrand_dsigmaBox_strange130()

const double StandardModel::getIntegrand_dsigmaBox_strange130 ( double  x) const
protected

Definition at line 9104 of file StandardModel/src/StandardModel.cpp.

9105{
9106 double s = 130. * 130.;
9108}

◆ getIntegrand_dsigmaBox_strange133()

const double StandardModel::getIntegrand_dsigmaBox_strange133 ( double  x) const
protected

Definition at line 9110 of file StandardModel/src/StandardModel.cpp.

9111{
9112 double s = 133. * 133.;
9114}

◆ getIntegrand_dsigmaBox_strange136()

const double StandardModel::getIntegrand_dsigmaBox_strange136 ( double  x) const
protected

Definition at line 9116 of file StandardModel/src/StandardModel.cpp.

9117{
9118 double s = 136. * 136.;
9120}

◆ getIntegrand_dsigmaBox_strange161()

const double StandardModel::getIntegrand_dsigmaBox_strange161 ( double  x) const
protected

Definition at line 9122 of file StandardModel/src/StandardModel.cpp.

9123{
9124 double s = 161. * 161.;
9126}

◆ getIntegrand_dsigmaBox_strange167()

const double StandardModel::getIntegrand_dsigmaBox_strange167 ( double  x) const
protected

Definition at line 9128 of file StandardModel/src/StandardModel.cpp.

9129{
9130 double s = 167. * 167.;
9132}

◆ getIntegrand_dsigmaBox_strange172()

const double StandardModel::getIntegrand_dsigmaBox_strange172 ( double  x) const
protected

Definition at line 9136 of file StandardModel/src/StandardModel.cpp.

9137{
9138 double s = 172. * 172.;
9140}

◆ getIntegrand_dsigmaBox_strange183()

const double StandardModel::getIntegrand_dsigmaBox_strange183 ( double  x) const
protected

Definition at line 9142 of file StandardModel/src/StandardModel.cpp.

9143{
9144 double s = 183. * 183.;
9146}

◆ getIntegrand_dsigmaBox_strange189()

const double StandardModel::getIntegrand_dsigmaBox_strange189 ( double  x) const
protected

Definition at line 9148 of file StandardModel/src/StandardModel.cpp.

9149{
9150 double s = 189. * 189.;
9152}

◆ getIntegrand_dsigmaBox_strange192()

const double StandardModel::getIntegrand_dsigmaBox_strange192 ( double  x) const
protected

Definition at line 9154 of file StandardModel/src/StandardModel.cpp.

9155{
9156 double s = 192. * 192.;
9158}

◆ getIntegrand_dsigmaBox_strange196()

const double StandardModel::getIntegrand_dsigmaBox_strange196 ( double  x) const
protected

Definition at line 9160 of file StandardModel/src/StandardModel.cpp.

9161{
9162 double s = 196. * 196.;
9164}

◆ getIntegrand_dsigmaBox_strange200()

const double StandardModel::getIntegrand_dsigmaBox_strange200 ( double  x) const
protected

Definition at line 9166 of file StandardModel/src/StandardModel.cpp.

9167{
9168 double s = 200. * 200.;
9170}

◆ getIntegrand_dsigmaBox_strange202()

const double StandardModel::getIntegrand_dsigmaBox_strange202 ( double  x) const
protected

Definition at line 9172 of file StandardModel/src/StandardModel.cpp.

9173{
9174 double s = 202. * 202.;
9176}

◆ getIntegrand_dsigmaBox_strange205()

const double StandardModel::getIntegrand_dsigmaBox_strange205 ( double  x) const
protected

Definition at line 9178 of file StandardModel/src/StandardModel.cpp.

9179{
9180 double s = 205. * 205.;
9182}

◆ getIntegrand_dsigmaBox_strange207()

const double StandardModel::getIntegrand_dsigmaBox_strange207 ( double  x) const
protected

Definition at line 9184 of file StandardModel/src/StandardModel.cpp.

9185{
9186 double s = 207. * 207.;
9188}

◆ getIntegrand_dsigmaBox_tau130()

const double StandardModel::getIntegrand_dsigmaBox_tau130 ( double  x) const
protected

Definition at line 8752 of file StandardModel/src/StandardModel.cpp.

8753{
8754 double s = 130. * 130.;
8755 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8756}

◆ getIntegrand_dsigmaBox_tau133()

const double StandardModel::getIntegrand_dsigmaBox_tau133 ( double  x) const
protected

◆ getIntegrand_dsigmaBox_tau136()

const double StandardModel::getIntegrand_dsigmaBox_tau136 ( double  x) const
protected

Definition at line 8758 of file StandardModel/src/StandardModel.cpp.

8759{
8760 double s = 136. * 136.;
8761 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8762}

◆ getIntegrand_dsigmaBox_tau161()

const double StandardModel::getIntegrand_dsigmaBox_tau161 ( double  x) const
protected

Definition at line 8764 of file StandardModel/src/StandardModel.cpp.

8765{
8766 double s = 161. * 161.;
8767 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8768}

◆ getIntegrand_dsigmaBox_tau167()

const double StandardModel::getIntegrand_dsigmaBox_tau167 ( double  x) const
protected

◆ getIntegrand_dsigmaBox_tau172()

const double StandardModel::getIntegrand_dsigmaBox_tau172 ( double  x) const
protected

Definition at line 8770 of file StandardModel/src/StandardModel.cpp.

8771{
8772 double s = 172. * 172.;
8773 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8774}

◆ getIntegrand_dsigmaBox_tau183()

const double StandardModel::getIntegrand_dsigmaBox_tau183 ( double  x) const
protected

Definition at line 8776 of file StandardModel/src/StandardModel.cpp.

8777{
8778 double s = 183. * 183.;
8779 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8780}

◆ getIntegrand_dsigmaBox_tau189()

const double StandardModel::getIntegrand_dsigmaBox_tau189 ( double  x) const
protected

Definition at line 8782 of file StandardModel/src/StandardModel.cpp.

8783{
8784 double s = 189. * 189.;
8785 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8786}

◆ getIntegrand_dsigmaBox_tau192()

const double StandardModel::getIntegrand_dsigmaBox_tau192 ( double  x) const
protected

Definition at line 8788 of file StandardModel/src/StandardModel.cpp.

8789{
8790 double s = 192. * 192.;
8791 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8792}

◆ getIntegrand_dsigmaBox_tau196()

const double StandardModel::getIntegrand_dsigmaBox_tau196 ( double  x) const
protected

Definition at line 8794 of file StandardModel/src/StandardModel.cpp.

8795{
8796 double s = 196. * 196.;
8797 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8798}

◆ getIntegrand_dsigmaBox_tau200()

const double StandardModel::getIntegrand_dsigmaBox_tau200 ( double  x) const
protected

Definition at line 8800 of file StandardModel/src/StandardModel.cpp.

8801{
8802 double s = 200. * 200.;
8803 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8804}

◆ getIntegrand_dsigmaBox_tau202()

const double StandardModel::getIntegrand_dsigmaBox_tau202 ( double  x) const
protected

Definition at line 8806 of file StandardModel/src/StandardModel.cpp.

8807{
8808 double s = 202. * 202.;
8809 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8810}

◆ getIntegrand_dsigmaBox_tau205()

const double StandardModel::getIntegrand_dsigmaBox_tau205 ( double  x) const
protected

Definition at line 8812 of file StandardModel/src/StandardModel.cpp.

8813{
8814 double s = 205. * 205.;
8815 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8816}

◆ getIntegrand_dsigmaBox_tau207()

const double StandardModel::getIntegrand_dsigmaBox_tau207 ( double  x) const
protected

Definition at line 8818 of file StandardModel/src/StandardModel.cpp.

8819{
8820 double s = 207. * 207.;
8821 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8822}

◆ getIntegrand_dsigmaBox_up130()

const double StandardModel::getIntegrand_dsigmaBox_up130 ( double  x) const
protected

Definition at line 8841 of file StandardModel/src/StandardModel.cpp.

8842{
8843 double s = 130. * 130.;
8844 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8845}

◆ getIntegrand_dsigmaBox_up133()

const double StandardModel::getIntegrand_dsigmaBox_up133 ( double  x) const
protected

Definition at line 8847 of file StandardModel/src/StandardModel.cpp.

8848{
8849 double s = 133. * 133.;
8850 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8851}

◆ getIntegrand_dsigmaBox_up136()

const double StandardModel::getIntegrand_dsigmaBox_up136 ( double  x) const
protected

Definition at line 8853 of file StandardModel/src/StandardModel.cpp.

8854{
8855 double s = 136. * 136.;
8856 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8857}

◆ getIntegrand_dsigmaBox_up161()

const double StandardModel::getIntegrand_dsigmaBox_up161 ( double  x) const
protected

Definition at line 8859 of file StandardModel/src/StandardModel.cpp.

8860{
8861 double s = 161. * 161.;
8862 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8863}

◆ getIntegrand_dsigmaBox_up167()

const double StandardModel::getIntegrand_dsigmaBox_up167 ( double  x) const
protected

Definition at line 8865 of file StandardModel/src/StandardModel.cpp.

8866{
8867 double s = 167. * 167.;
8868 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8869}

◆ getIntegrand_dsigmaBox_up172()

const double StandardModel::getIntegrand_dsigmaBox_up172 ( double  x) const
protected

Definition at line 8871 of file StandardModel/src/StandardModel.cpp.

8872{
8873 double s = 172. * 172.;
8874 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8875}

◆ getIntegrand_dsigmaBox_up183()

const double StandardModel::getIntegrand_dsigmaBox_up183 ( double  x) const
protected

Definition at line 8877 of file StandardModel/src/StandardModel.cpp.

8878{
8879 double s = 183. * 183.;
8880 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8881}

◆ getIntegrand_dsigmaBox_up189()

const double StandardModel::getIntegrand_dsigmaBox_up189 ( double  x) const
protected

Definition at line 8883 of file StandardModel/src/StandardModel.cpp.

8884{
8885 double s = 189. * 189.;
8886 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8887}

◆ getIntegrand_dsigmaBox_up192()

const double StandardModel::getIntegrand_dsigmaBox_up192 ( double  x) const
protected

Definition at line 8889 of file StandardModel/src/StandardModel.cpp.

8890{
8891 double s = 192. * 192.;
8892 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8893}

◆ getIntegrand_dsigmaBox_up196()

const double StandardModel::getIntegrand_dsigmaBox_up196 ( double  x) const
protected

Definition at line 8895 of file StandardModel/src/StandardModel.cpp.

8896{
8897 double s = 196. * 196.;
8898 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8899}

◆ getIntegrand_dsigmaBox_up200()

const double StandardModel::getIntegrand_dsigmaBox_up200 ( double  x) const
protected

Definition at line 8901 of file StandardModel/src/StandardModel.cpp.

8902{
8903 double s = 200. * 200.;
8904 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8905}

◆ getIntegrand_dsigmaBox_up202()

const double StandardModel::getIntegrand_dsigmaBox_up202 ( double  x) const
protected

Definition at line 8907 of file StandardModel/src/StandardModel.cpp.

8908{
8909 double s = 202. * 202.;
8910 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8911}

◆ getIntegrand_dsigmaBox_up205()

const double StandardModel::getIntegrand_dsigmaBox_up205 ( double  x) const
protected

Definition at line 8913 of file StandardModel/src/StandardModel.cpp.

8914{
8915 double s = 205. * 205.;
8916 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8917}

◆ getIntegrand_dsigmaBox_up207()

const double StandardModel::getIntegrand_dsigmaBox_up207 ( double  x) const
protected

Definition at line 8919 of file StandardModel/src/StandardModel.cpp.

8920{
8921 double s = 207. * 207.;
8922 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8923}

◆ getIntegrand_sigmaWithISR_bottom130()

const double StandardModel::getIntegrand_sigmaWithISR_bottom130 ( double  x) const
protected

Definition at line 8582 of file StandardModel/src/StandardModel.cpp.

8583{
8584 double s = 130. * 130.;
8586}
const double Integrand_sigmaWithISR_q(double x, const QCD::quark q_flavor, const double s) const

◆ getIntegrand_sigmaWithISR_bottom133()

const double StandardModel::getIntegrand_sigmaWithISR_bottom133 ( double  x) const
protected

Definition at line 8588 of file StandardModel/src/StandardModel.cpp.

8589{
8590 double s = 133. * 133.;
8592}

◆ getIntegrand_sigmaWithISR_bottom136()

const double StandardModel::getIntegrand_sigmaWithISR_bottom136 ( double  x) const
protected

Definition at line 8594 of file StandardModel/src/StandardModel.cpp.

8595{
8596 double s = 136. * 136.;
8598}

◆ getIntegrand_sigmaWithISR_bottom161()

const double StandardModel::getIntegrand_sigmaWithISR_bottom161 ( double  x) const
protected

Definition at line 8600 of file StandardModel/src/StandardModel.cpp.

8601{
8602 double s = 161. * 161.;
8604}

◆ getIntegrand_sigmaWithISR_bottom167()

const double StandardModel::getIntegrand_sigmaWithISR_bottom167 ( double  x) const
protected

Definition at line 8606 of file StandardModel/src/StandardModel.cpp.

8607{
8608 double s = 167. * 167.;
8610}

◆ getIntegrand_sigmaWithISR_bottom172()

const double StandardModel::getIntegrand_sigmaWithISR_bottom172 ( double  x) const
protected

Definition at line 8612 of file StandardModel/src/StandardModel.cpp.

8613{
8614 double s = 172. * 172.;
8616}

◆ getIntegrand_sigmaWithISR_bottom183()

const double StandardModel::getIntegrand_sigmaWithISR_bottom183 ( double  x) const
protected

Definition at line 8618 of file StandardModel/src/StandardModel.cpp.

8619{
8620 double s = 183. * 183.;
8622}

◆ getIntegrand_sigmaWithISR_bottom189()

const double StandardModel::getIntegrand_sigmaWithISR_bottom189 ( double  x) const
protected

Definition at line 8624 of file StandardModel/src/StandardModel.cpp.

8625{
8626 double s = 189. * 189.;
8628}

◆ getIntegrand_sigmaWithISR_bottom192()

const double StandardModel::getIntegrand_sigmaWithISR_bottom192 ( double  x) const
protected

Definition at line 8630 of file StandardModel/src/StandardModel.cpp.

8631{
8632 double s = 192. * 192.;
8634}

◆ getIntegrand_sigmaWithISR_bottom196()

const double StandardModel::getIntegrand_sigmaWithISR_bottom196 ( double  x) const
protected

Definition at line 8636 of file StandardModel/src/StandardModel.cpp.

8637{
8638 double s = 196. * 196.;
8640}

◆ getIntegrand_sigmaWithISR_bottom200()

const double StandardModel::getIntegrand_sigmaWithISR_bottom200 ( double  x) const
protected

Definition at line 8642 of file StandardModel/src/StandardModel.cpp.

8643{
8644 double s = 200. * 200.;
8646}

◆ getIntegrand_sigmaWithISR_bottom202()

const double StandardModel::getIntegrand_sigmaWithISR_bottom202 ( double  x) const
protected

Definition at line 8648 of file StandardModel/src/StandardModel.cpp.

8649{
8650 double s = 202. * 202.;
8652}

◆ getIntegrand_sigmaWithISR_bottom205()

const double StandardModel::getIntegrand_sigmaWithISR_bottom205 ( double  x) const
protected

Definition at line 8654 of file StandardModel/src/StandardModel.cpp.

8655{
8656 double s = 205. * 205.;
8658}

◆ getIntegrand_sigmaWithISR_bottom207()

const double StandardModel::getIntegrand_sigmaWithISR_bottom207 ( double  x) const
protected

Definition at line 8660 of file StandardModel/src/StandardModel.cpp.

8661{
8662 double s = 207. * 207.;
8664}

◆ getIntegrand_sigmaWithISR_charm130()

const double StandardModel::getIntegrand_sigmaWithISR_charm130 ( double  x) const
protected

Definition at line 8406 of file StandardModel/src/StandardModel.cpp.

8407{
8408 double s = 130. * 130.;
8410}

◆ getIntegrand_sigmaWithISR_charm133()

const double StandardModel::getIntegrand_sigmaWithISR_charm133 ( double  x) const
protected

Definition at line 8412 of file StandardModel/src/StandardModel.cpp.

8413{
8414 double s = 133. * 133.;
8416}

◆ getIntegrand_sigmaWithISR_charm136()

const double StandardModel::getIntegrand_sigmaWithISR_charm136 ( double  x) const
protected

Definition at line 8418 of file StandardModel/src/StandardModel.cpp.

8419{
8420 double s = 136. * 136.;
8422}

◆ getIntegrand_sigmaWithISR_charm161()

const double StandardModel::getIntegrand_sigmaWithISR_charm161 ( double  x) const
protected

Definition at line 8424 of file StandardModel/src/StandardModel.cpp.

8425{
8426 double s = 161. * 161.;
8428}

◆ getIntegrand_sigmaWithISR_charm167()

const double StandardModel::getIntegrand_sigmaWithISR_charm167 ( double  x) const
protected

Definition at line 8430 of file StandardModel/src/StandardModel.cpp.

8431{
8432 double s = 167. * 167.;
8434}

◆ getIntegrand_sigmaWithISR_charm172()

const double StandardModel::getIntegrand_sigmaWithISR_charm172 ( double  x) const
protected

Definition at line 8436 of file StandardModel/src/StandardModel.cpp.

8437{
8438 double s = 172. * 172.;
8440}

◆ getIntegrand_sigmaWithISR_charm183()

const double StandardModel::getIntegrand_sigmaWithISR_charm183 ( double  x) const
protected

Definition at line 8442 of file StandardModel/src/StandardModel.cpp.

8443{
8444 double s = 183. * 183.;
8446}

◆ getIntegrand_sigmaWithISR_charm189()

const double StandardModel::getIntegrand_sigmaWithISR_charm189 ( double  x) const
protected

Definition at line 8448 of file StandardModel/src/StandardModel.cpp.

8449{
8450 double s = 189. * 189.;
8452}

◆ getIntegrand_sigmaWithISR_charm192()

const double StandardModel::getIntegrand_sigmaWithISR_charm192 ( double  x) const
protected

Definition at line 8454 of file StandardModel/src/StandardModel.cpp.

8455{
8456 double s = 192. * 192.;
8458}

◆ getIntegrand_sigmaWithISR_charm196()

const double StandardModel::getIntegrand_sigmaWithISR_charm196 ( double  x) const
protected

Definition at line 8460 of file StandardModel/src/StandardModel.cpp.

8461{
8462 double s = 196. * 196.;
8464}

◆ getIntegrand_sigmaWithISR_charm200()

const double StandardModel::getIntegrand_sigmaWithISR_charm200 ( double  x) const
protected

Definition at line 8466 of file StandardModel/src/StandardModel.cpp.

8467{
8468 double s = 200. * 200.;
8470}

◆ getIntegrand_sigmaWithISR_charm202()

const double StandardModel::getIntegrand_sigmaWithISR_charm202 ( double  x) const
protected

Definition at line 8472 of file StandardModel/src/StandardModel.cpp.

8473{
8474 double s = 202. * 202.;
8476}

◆ getIntegrand_sigmaWithISR_charm205()

const double StandardModel::getIntegrand_sigmaWithISR_charm205 ( double  x) const
protected

Definition at line 8478 of file StandardModel/src/StandardModel.cpp.

8479{
8480 double s = 205. * 205.;
8482}

◆ getIntegrand_sigmaWithISR_charm207()

const double StandardModel::getIntegrand_sigmaWithISR_charm207 ( double  x) const
protected

Definition at line 8484 of file StandardModel/src/StandardModel.cpp.

8485{
8486 double s = 207. * 207.;
8488}

◆ getIntegrand_sigmaWithISR_down130()

const double StandardModel::getIntegrand_sigmaWithISR_down130 ( double  x) const
protected

Definition at line 8317 of file StandardModel/src/StandardModel.cpp.

8318{
8319 double s = 130. * 130.;
8321}

◆ getIntegrand_sigmaWithISR_down133()

const double StandardModel::getIntegrand_sigmaWithISR_down133 ( double  x) const
protected

Definition at line 8323 of file StandardModel/src/StandardModel.cpp.

8324{
8325 double s = 133. * 133.;
8327}

◆ getIntegrand_sigmaWithISR_down136()

const double StandardModel::getIntegrand_sigmaWithISR_down136 ( double  x) const
protected

Definition at line 8330 of file StandardModel/src/StandardModel.cpp.

8331{
8332 double s = 136. * 136.;
8334}

◆ getIntegrand_sigmaWithISR_down161()

const double StandardModel::getIntegrand_sigmaWithISR_down161 ( double  x) const
protected

Definition at line 8336 of file StandardModel/src/StandardModel.cpp.

8337{
8338 double s = 161. * 161.;
8340}

◆ getIntegrand_sigmaWithISR_down167()

const double StandardModel::getIntegrand_sigmaWithISR_down167 ( double  x) const
protected

Definition at line 8342 of file StandardModel/src/StandardModel.cpp.

8343{
8344 double s = 167. * 167.;
8346}

◆ getIntegrand_sigmaWithISR_down172()

const double StandardModel::getIntegrand_sigmaWithISR_down172 ( double  x) const
protected

Definition at line 8348 of file StandardModel/src/StandardModel.cpp.

8349{
8350 double s = 172. * 172.;
8352}

◆ getIntegrand_sigmaWithISR_down183()

const double StandardModel::getIntegrand_sigmaWithISR_down183 ( double  x) const
protected

Definition at line 8354 of file StandardModel/src/StandardModel.cpp.

8355{
8356 double s = 183. * 183.;
8358}

◆ getIntegrand_sigmaWithISR_down189()

const double StandardModel::getIntegrand_sigmaWithISR_down189 ( double  x) const
protected

Definition at line 8360 of file StandardModel/src/StandardModel.cpp.

8361{
8362 double s = 189. * 189.;
8364}

◆ getIntegrand_sigmaWithISR_down192()

const double StandardModel::getIntegrand_sigmaWithISR_down192 ( double  x) const
protected

Definition at line 8366 of file StandardModel/src/StandardModel.cpp.

8367{
8368 double s = 192. * 192.;
8370}

◆ getIntegrand_sigmaWithISR_down196()

const double StandardModel::getIntegrand_sigmaWithISR_down196 ( double  x) const
protected

Definition at line 8372 of file StandardModel/src/StandardModel.cpp.

8373{
8374 double s = 196. * 196.;
8376}

◆ getIntegrand_sigmaWithISR_down200()

const double StandardModel::getIntegrand_sigmaWithISR_down200 ( double  x) const
protected

Definition at line 8378 of file StandardModel/src/StandardModel.cpp.

8379{
8380 double s = 200. * 200.;
8382}

◆ getIntegrand_sigmaWithISR_down202()

const double StandardModel::getIntegrand_sigmaWithISR_down202 ( double  x) const
protected

Definition at line 8384 of file StandardModel/src/StandardModel.cpp.

8385{
8386 double s = 202. * 202.;
8388}

◆ getIntegrand_sigmaWithISR_down205()

const double StandardModel::getIntegrand_sigmaWithISR_down205 ( double  x) const
protected

Definition at line 8390 of file StandardModel/src/StandardModel.cpp.

8391{
8392 double s = 205. * 205.;
8394}

◆ getIntegrand_sigmaWithISR_down207()

const double StandardModel::getIntegrand_sigmaWithISR_down207 ( double  x) const
protected

Definition at line 8396 of file StandardModel/src/StandardModel.cpp.

8397{
8398 double s = 207. * 207.;
8400}

◆ getIntegrand_sigmaWithISR_mu130()

const double StandardModel::getIntegrand_sigmaWithISR_mu130 ( double  x) const
protected

Definition at line 8061 of file StandardModel/src/StandardModel.cpp.

8062{
8063 double s = 130. * 130.;
8065}
const double Integrand_sigmaWithISR_l(double x, const QCD::lepton l_flavor, const double s) const

◆ getIntegrand_sigmaWithISR_mu136()

const double StandardModel::getIntegrand_sigmaWithISR_mu136 ( double  x) const
protected

Definition at line 8067 of file StandardModel/src/StandardModel.cpp.

8068{
8069 double s = 136. * 136.;
8071}

◆ getIntegrand_sigmaWithISR_mu161()

const double StandardModel::getIntegrand_sigmaWithISR_mu161 ( double  x) const
protected

Definition at line 8073 of file StandardModel/src/StandardModel.cpp.

8074{
8075 double s = 161. * 161.;
8077}

◆ getIntegrand_sigmaWithISR_mu172()

const double StandardModel::getIntegrand_sigmaWithISR_mu172 ( double  x) const
protected

Definition at line 8079 of file StandardModel/src/StandardModel.cpp.

8080{
8081 double s = 172. * 172.;
8083}

◆ getIntegrand_sigmaWithISR_mu183()

const double StandardModel::getIntegrand_sigmaWithISR_mu183 ( double  x) const
protected

Definition at line 8085 of file StandardModel/src/StandardModel.cpp.

8086{
8087 double s = 183. * 183.;
8089}

◆ getIntegrand_sigmaWithISR_mu189()

const double StandardModel::getIntegrand_sigmaWithISR_mu189 ( double  x) const
protected

Definition at line 8091 of file StandardModel/src/StandardModel.cpp.

8092{
8093 double s = 189. * 189.;
8095}

◆ getIntegrand_sigmaWithISR_mu192()

const double StandardModel::getIntegrand_sigmaWithISR_mu192 ( double  x) const
protected

Definition at line 8097 of file StandardModel/src/StandardModel.cpp.

8098{
8099 double s = 192. * 192.;
8101}

◆ getIntegrand_sigmaWithISR_mu196()

const double StandardModel::getIntegrand_sigmaWithISR_mu196 ( double  x) const
protected

Definition at line 8103 of file StandardModel/src/StandardModel.cpp.

8104{
8105 double s = 196. * 196.;
8107}

◆ getIntegrand_sigmaWithISR_mu200()

const double StandardModel::getIntegrand_sigmaWithISR_mu200 ( double  x) const
protected

Definition at line 8109 of file StandardModel/src/StandardModel.cpp.

8110{
8111 double s = 200. * 200.;
8113}

◆ getIntegrand_sigmaWithISR_mu202()

const double StandardModel::getIntegrand_sigmaWithISR_mu202 ( double  x) const
protected

Definition at line 8115 of file StandardModel/src/StandardModel.cpp.

8116{
8117 double s = 202. * 202.;
8119}

◆ getIntegrand_sigmaWithISR_mu205()

const double StandardModel::getIntegrand_sigmaWithISR_mu205 ( double  x) const
protected

Definition at line 8121 of file StandardModel/src/StandardModel.cpp.

8122{
8123 double s = 205. * 205.;
8125}

◆ getIntegrand_sigmaWithISR_mu207()

const double StandardModel::getIntegrand_sigmaWithISR_mu207 ( double  x) const
protected

Definition at line 8127 of file StandardModel/src/StandardModel.cpp.

8128{
8129 double s = 207. * 207.;
8131}

◆ getIntegrand_sigmaWithISR_strange130()

const double StandardModel::getIntegrand_sigmaWithISR_strange130 ( double  x) const
protected

Definition at line 8494 of file StandardModel/src/StandardModel.cpp.

8495{
8496 double s = 130. * 130.;
8498}

◆ getIntegrand_sigmaWithISR_strange133()

const double StandardModel::getIntegrand_sigmaWithISR_strange133 ( double  x) const
protected

Definition at line 8500 of file StandardModel/src/StandardModel.cpp.

8501{
8502 double s = 133. * 133.;
8504}

◆ getIntegrand_sigmaWithISR_strange136()

const double StandardModel::getIntegrand_sigmaWithISR_strange136 ( double  x) const
protected

Definition at line 8506 of file StandardModel/src/StandardModel.cpp.

8507{
8508 double s = 136. * 136.;
8510}

◆ getIntegrand_sigmaWithISR_strange161()

const double StandardModel::getIntegrand_sigmaWithISR_strange161 ( double  x) const
protected

Definition at line 8512 of file StandardModel/src/StandardModel.cpp.

8513{
8514 double s = 161. * 161.;
8516}

◆ getIntegrand_sigmaWithISR_strange167()

const double StandardModel::getIntegrand_sigmaWithISR_strange167 ( double  x) const
protected

Definition at line 8518 of file StandardModel/src/StandardModel.cpp.

8519{
8520 double s = 167. * 167.;
8522}

◆ getIntegrand_sigmaWithISR_strange172()

const double StandardModel::getIntegrand_sigmaWithISR_strange172 ( double  x) const
protected

Definition at line 8524 of file StandardModel/src/StandardModel.cpp.

8525{
8526 double s = 172. * 172.;
8528}

◆ getIntegrand_sigmaWithISR_strange183()

const double StandardModel::getIntegrand_sigmaWithISR_strange183 ( double  x) const
protected

Definition at line 8530 of file StandardModel/src/StandardModel.cpp.

8531{
8532 double s = 183. * 183.;
8534}

◆ getIntegrand_sigmaWithISR_strange189()

const double StandardModel::getIntegrand_sigmaWithISR_strange189 ( double  x) const
protected

Definition at line 8536 of file StandardModel/src/StandardModel.cpp.

8537{
8538 double s = 189. * 189.;
8540}

◆ getIntegrand_sigmaWithISR_strange192()

const double StandardModel::getIntegrand_sigmaWithISR_strange192 ( double  x) const
protected

Definition at line 8542 of file StandardModel/src/StandardModel.cpp.

8543{
8544 double s = 192. * 192.;
8546}

◆ getIntegrand_sigmaWithISR_strange196()

const double StandardModel::getIntegrand_sigmaWithISR_strange196 ( double  x) const
protected

Definition at line 8548 of file StandardModel/src/StandardModel.cpp.

8549{
8550 double s = 196. * 196.;
8552}

◆ getIntegrand_sigmaWithISR_strange200()

const double StandardModel::getIntegrand_sigmaWithISR_strange200 ( double  x) const
protected

Definition at line 8554 of file StandardModel/src/StandardModel.cpp.

8555{
8556 double s = 200. * 200.;
8558}

◆ getIntegrand_sigmaWithISR_strange202()

const double StandardModel::getIntegrand_sigmaWithISR_strange202 ( double  x) const
protected

Definition at line 8560 of file StandardModel/src/StandardModel.cpp.

8561{
8562 double s = 202. * 202.;
8564}

◆ getIntegrand_sigmaWithISR_strange205()

const double StandardModel::getIntegrand_sigmaWithISR_strange205 ( double  x) const
protected

Definition at line 8566 of file StandardModel/src/StandardModel.cpp.

8567{
8568 double s = 205. * 205.;
8570}

◆ getIntegrand_sigmaWithISR_strange207()

const double StandardModel::getIntegrand_sigmaWithISR_strange207 ( double  x) const
protected

Definition at line 8572 of file StandardModel/src/StandardModel.cpp.

8573{
8574 double s = 207. * 207.;
8576}

◆ getIntegrand_sigmaWithISR_tau130()

const double StandardModel::getIntegrand_sigmaWithISR_tau130 ( double  x) const
protected

Definition at line 8134 of file StandardModel/src/StandardModel.cpp.

8135{
8136 double s = 130. * 130.;
8138}

◆ getIntegrand_sigmaWithISR_tau136()

const double StandardModel::getIntegrand_sigmaWithISR_tau136 ( double  x) const
protected

Definition at line 8140 of file StandardModel/src/StandardModel.cpp.

8141{
8142 double s = 136. * 136.;
8144}

◆ getIntegrand_sigmaWithISR_tau161()

const double StandardModel::getIntegrand_sigmaWithISR_tau161 ( double  x) const
protected

Definition at line 8146 of file StandardModel/src/StandardModel.cpp.

8147{
8148 double s = 161. * 161.;
8150}

◆ getIntegrand_sigmaWithISR_tau172()

const double StandardModel::getIntegrand_sigmaWithISR_tau172 ( double  x) const
protected

Definition at line 8152 of file StandardModel/src/StandardModel.cpp.

8153{
8154 double s = 172. * 172.;
8156}

◆ getIntegrand_sigmaWithISR_tau183()

const double StandardModel::getIntegrand_sigmaWithISR_tau183 ( double  x) const
protected

Definition at line 8158 of file StandardModel/src/StandardModel.cpp.

8159{
8160 double s = 183. * 183.;
8162}

◆ getIntegrand_sigmaWithISR_tau189()

const double StandardModel::getIntegrand_sigmaWithISR_tau189 ( double  x) const
protected

Definition at line 8164 of file StandardModel/src/StandardModel.cpp.

8165{
8166 double s = 189. * 189.;
8168}

◆ getIntegrand_sigmaWithISR_tau192()

const double StandardModel::getIntegrand_sigmaWithISR_tau192 ( double  x) const
protected

Definition at line 8170 of file StandardModel/src/StandardModel.cpp.

8171{
8172 double s = 192. * 192.;
8174}

◆ getIntegrand_sigmaWithISR_tau196()

const double StandardModel::getIntegrand_sigmaWithISR_tau196 ( double  x) const
protected

Definition at line 8176 of file StandardModel/src/StandardModel.cpp.

8177{
8178 double s = 196. * 196.;
8180}

◆ getIntegrand_sigmaWithISR_tau200()

const double StandardModel::getIntegrand_sigmaWithISR_tau200 ( double  x) const
protected

Definition at line 8182 of file StandardModel/src/StandardModel.cpp.

8183{
8184 double s = 200. * 200.;
8186}

◆ getIntegrand_sigmaWithISR_tau202()

const double StandardModel::getIntegrand_sigmaWithISR_tau202 ( double  x) const
protected

Definition at line 8188 of file StandardModel/src/StandardModel.cpp.

8189{
8190 double s = 202. * 202.;
8192}

◆ getIntegrand_sigmaWithISR_tau205()

const double StandardModel::getIntegrand_sigmaWithISR_tau205 ( double  x) const
protected

Definition at line 8194 of file StandardModel/src/StandardModel.cpp.

8195{
8196 double s = 205. * 205.;
8198}

◆ getIntegrand_sigmaWithISR_tau207()

const double StandardModel::getIntegrand_sigmaWithISR_tau207 ( double  x) const
protected

Definition at line 8200 of file StandardModel/src/StandardModel.cpp.

8201{
8202 double s = 207. * 207.;
8204}

◆ getIntegrand_sigmaWithISR_up130()

const double StandardModel::getIntegrand_sigmaWithISR_up130 ( double  x) const
protected

Definition at line 8230 of file StandardModel/src/StandardModel.cpp.

8231{
8232 double s = 130. * 130.;
8233 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8234}

◆ getIntegrand_sigmaWithISR_up133()

const double StandardModel::getIntegrand_sigmaWithISR_up133 ( double  x) const
protected

Definition at line 8236 of file StandardModel/src/StandardModel.cpp.

8237{
8238 double s = 133. * 133.;
8239 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8240}

◆ getIntegrand_sigmaWithISR_up136()

const double StandardModel::getIntegrand_sigmaWithISR_up136 ( double  x) const
protected

Definition at line 8242 of file StandardModel/src/StandardModel.cpp.

8243{
8244 double s = 136. * 136.;
8245 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8246}

◆ getIntegrand_sigmaWithISR_up161()

const double StandardModel::getIntegrand_sigmaWithISR_up161 ( double  x) const
protected

Definition at line 8248 of file StandardModel/src/StandardModel.cpp.

8249{
8250 double s = 161. * 161.;
8251 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8252}

◆ getIntegrand_sigmaWithISR_up167()

const double StandardModel::getIntegrand_sigmaWithISR_up167 ( double  x) const
protected

Definition at line 8254 of file StandardModel/src/StandardModel.cpp.

8255{
8256 double s = 167. * 167.;
8257 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8258}

◆ getIntegrand_sigmaWithISR_up172()

const double StandardModel::getIntegrand_sigmaWithISR_up172 ( double  x) const
protected

Definition at line 8260 of file StandardModel/src/StandardModel.cpp.

8261{
8262 double s = 172. * 172.;
8263 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8264}

◆ getIntegrand_sigmaWithISR_up183()

const double StandardModel::getIntegrand_sigmaWithISR_up183 ( double  x) const
protected

Definition at line 8266 of file StandardModel/src/StandardModel.cpp.

8267{
8268 double s = 183. * 183.;
8269 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8270}

◆ getIntegrand_sigmaWithISR_up189()

const double StandardModel::getIntegrand_sigmaWithISR_up189 ( double  x) const
protected

Definition at line 8272 of file StandardModel/src/StandardModel.cpp.

8273{
8274 double s = 189. * 189.;
8275 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8276}

◆ getIntegrand_sigmaWithISR_up192()

const double StandardModel::getIntegrand_sigmaWithISR_up192 ( double  x) const
protected

Definition at line 8278 of file StandardModel/src/StandardModel.cpp.

8279{
8280 double s = 192. * 192.;
8281 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8282}

◆ getIntegrand_sigmaWithISR_up196()

const double StandardModel::getIntegrand_sigmaWithISR_up196 ( double  x) const
protected

Definition at line 8284 of file StandardModel/src/StandardModel.cpp.

8285{
8286 double s = 196. * 196.;
8287 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8288}

◆ getIntegrand_sigmaWithISR_up200()

const double StandardModel::getIntegrand_sigmaWithISR_up200 ( double  x) const
protected

Definition at line 8290 of file StandardModel/src/StandardModel.cpp.

8291{
8292 double s = 200. * 200.;
8293 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8294}

◆ getIntegrand_sigmaWithISR_up202()

const double StandardModel::getIntegrand_sigmaWithISR_up202 ( double  x) const
protected

Definition at line 8296 of file StandardModel/src/StandardModel.cpp.

8297{
8298 double s = 202. * 202.;
8299 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8300}

◆ getIntegrand_sigmaWithISR_up205()

const double StandardModel::getIntegrand_sigmaWithISR_up205 ( double  x) const
protected

Definition at line 8302 of file StandardModel/src/StandardModel.cpp.

8303{
8304 double s = 205. * 205.;
8305 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8306}

◆ getIntegrand_sigmaWithISR_up207()

const double StandardModel::getIntegrand_sigmaWithISR_up207 ( double  x) const
protected

Definition at line 8308 of file StandardModel/src/StandardModel.cpp.

8309{
8310 double s = 207. * 207.;
8311 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8312}

◆ getIterationNo()

const int StandardModel::getIterationNo ( ) const
inline

Definition at line 617 of file StandardModel.h.

618 {
619 return iterationNo;
620 }

◆ getLeptons()

const Particle & StandardModel::getLeptons ( const QCD::lepton  p) const
inline

A get method to retrieve the member object of a lepton.

Parameters
[in]pname of a lepton
Returns
an object of the lepton specified by name

Definition at line 744 of file StandardModel.h.

745 {
746 return leptons[p];
747 }

◆ getMatching()

virtual StandardModelMatching & StandardModel::getMatching ( ) const
inlinevirtual

A get method to access the member reference of type StandardModelMatching.

Returns
a reference to a StandardModelMatching object

Reimplemented in CMFV, FlavourWilsonCoefficient, FlavourWilsonCoefficient_DF2, LoopMediators, RealWeakEFTLFV, GeorgiMachacek, LeftRightSymmetricModel, NPSMEFTd6, NPSMEFTd6General, SUSY, SUSYMassInsertion, THDM, and THDMW.

Definition at line 965 of file StandardModel.h.

966 {
967 return SMM.getObj();
968 }

◆ getMHl()

virtual const double StandardModel::getMHl ( ) const
inlinevirtual

A get method to retrieve the Higgs mass \(m_h\).

Returns
\(m_h\) in GeV

Reimplemented in SUSY.

Definition at line 809 of file StandardModel.h.

810 {
811 return mHl;
812 }

◆ getmq()

virtual const double StandardModel::getmq ( const QCD::quark  q,
const double  mu 
) const
inlinevirtual

The MSbar running quark mass computed at NLO.

Parameters
qthe quark flavour
muthe scale at which the running mass is returned
Returns
\( m_q^\overline{\mathrm{MS}}(\mu)\)

Definition at line 3310 of file StandardModel.h.

3311{
3312 return m_q(q, mu, FULLNLO);
3313}

◆ getMuw()

const double StandardModel::getMuw ( ) const
inline

A get method to retrieve the matching scale \(\mu_W\) around the weak scale.

Returns
\(\mu_W\) in GeV

Definition at line 951 of file StandardModel.h.

952 {
953 return muw;
954 }

◆ getMw()

const double StandardModel::getMw ( ) const
inline

A get method to access the input value of the mass of the \(W\) boson \(M_W\).

Returns
the \(W\)-boson mass \(M_W\)

Definition at line 762 of file StandardModel.h.

763 {
764 return Mw_inp;
765 }

◆ getMyApproximateFormulae()

EWSMApproximateFormulae * StandardModel::getMyApproximateFormulae ( ) const
inline

A get method to retrieve the member pointer of type EWSMApproximateFormulae.

Returns
the pointer myApproximateFormulae

Definition at line 992 of file StandardModel.h.

993 {
995 }

◆ getMyEWSMcache()

EWSMcache * StandardModel::getMyEWSMcache ( ) const
inline

A get method to retrieve the member pointer of type EWSMcache.

Returns
the pointer myEWSMcache

Definition at line 974 of file StandardModel.h.

975 {
976 return myEWSMcache;
977 }

◆ getMyLeptonFlavour()

LeptonFlavour * StandardModel::getMyLeptonFlavour ( ) const
inline

Definition at line 1038 of file StandardModel.h.

1039 {
1040 return myLeptonFlavour;
1041 }

◆ getMyOneLoopEW()

EWSMOneLoopEW * StandardModel::getMyOneLoopEW ( ) const
inline

A get method to retrieve the member pointer of type EWSMOneLoopEW,.

Returns
the pointer myOneLoopEW

Definition at line 983 of file StandardModel.h.

984 {
985 return myOneLoopEW;
986 }

◆ getMyThreeLoopEW()

EWSMThreeLoopEW * StandardModel::getMyThreeLoopEW ( ) const
inline

Definition at line 1008 of file StandardModel.h.

1009 {
1010 return myThreeLoopEW;
1011 }

◆ getMyThreeLoopEW2QCD()

EWSMThreeLoopEW2QCD * StandardModel::getMyThreeLoopEW2QCD ( ) const
inline

Definition at line 1013 of file StandardModel.h.

1014 {
1015 return myThreeLoopEW2QCD;
1016 }

◆ getMyThreeLoopQCD()

EWSMThreeLoopQCD * StandardModel::getMyThreeLoopQCD ( ) const
inline

Definition at line 1018 of file StandardModel.h.

1019 {
1020 return myThreeLoopQCD;
1021 }

◆ getMyTwoFermionsLEP2()

EWSMTwoFermionsLEP2 * StandardModel::getMyTwoFermionsLEP2 ( ) const
inline

A get method to retrieve the member pointer of type EWSMTwoFermionsLEP2.

Returns
the pointer myTwoFermionsLEP2

Definition at line 1002 of file StandardModel.h.

1003 {
1004 return myTwoFermionsLEP2;
1005 }

◆ getMyTwoLoopEW()

EWSMTwoLoopEW * StandardModel::getMyTwoLoopEW ( ) const
inline

Definition at line 1023 of file StandardModel.h.

1024 {
1025 return myTwoLoopEW;
1026 }

◆ getMyTwoLoopQCD()

EWSMTwoLoopQCD * StandardModel::getMyTwoLoopQCD ( ) const
inline

Definition at line 1028 of file StandardModel.h.

1029 {
1030 return myTwoLoopQCD;
1031 }

◆ getMz()

const double StandardModel::getMz ( ) const
inline

A get method to access the mass of the \(Z\) boson \(M_Z\).

Returns
the \(Z\)-boson mass \(M_Z\)

Definition at line 753 of file StandardModel.h.

754 {
755 return Mz;
756 }

◆ getPhiBd()

virtual const double StandardModel::getPhiBd ( ) const
inlinevirtual

Half the relative phase of the $B_d$ mixing amplitude w.r.t. the Standard Model one.

Returns
\(1/2 (\mathrm{arg}((M_{12}^{bd})_\mathrm{full})-\mathrm{arg}((M_{12}^{bd})_\mathrm{SM}))\vert\)

Reimplemented in NPDF2.

Definition at line 3111 of file StandardModel.h.

3112 {
3113 return 0.;
3114 }

◆ getPhiBs()

virtual const double StandardModel::getPhiBs ( ) const
inlinevirtual

Half the relative phase of the $B_s$ mixing amplitude w.r.t. the Standard Model one.

Returns
\( 1/2 (\mathrm{arg}((M_{12}^{bs})_\mathrm{full})-\mathrm{arg}((M_{12}^{bs})_\mathrm{SM}))\vert\)

Reimplemented in NPDF2.

Definition at line 3102 of file StandardModel.h.

3103 {
3104 return 0.;
3105 }

◆ getTrueSM()

virtual const StandardModel & StandardModel::getTrueSM ( ) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 956 of file StandardModel.h.

957 {
958 throw std::runtime_error("StandardModel::getTrueSM() must be overridden by the NP extension.");
959 }

◆ getUPMNS()

const gslpp::matrix< gslpp::complex > StandardModel::getUPMNS ( ) const
inline

A get method to retrieve the object of the PMNS matrix.

Returns
the PMNS matrix

Definition at line 931 of file StandardModel.h.

932 {
933 return myPMNS.getPMNS();
934 }

◆ getVCKM()

const gslpp::matrix< gslpp::complex > StandardModel::getVCKM ( ) const
inline

A get method to retrieve the CKM matrix.

Returns
the CKM matrix

Definition at line 911 of file StandardModel.h.

912 {
913 return myCKM.getCKM();
914 }

◆ getYd()

const gslpp::matrix< gslpp::complex > & StandardModel::getYd ( ) const
inline

A get method to retrieve the Yukawa matrix of the down-type quarks, \(Y_d\).

Returns
\(Y_d\)

Definition at line 3358 of file StandardModel.h.

3359 {
3360 return Yd;
3361 }

◆ getYe()

const gslpp::matrix< gslpp::complex > & StandardModel::getYe ( ) const
inline

A get method to retrieve the Yukawa matrix of the charged leptons, \(Y_e\).

Returns
\(Y_e\)

Definition at line 3378 of file StandardModel.h.

3379 {
3380 return Ye;
3381 }

◆ getYn()

const gslpp::matrix< gslpp::complex > & StandardModel::getYn ( ) const
inline

A get method to retrieve the Yukawa matrix of the neutrinos, \(Y_\nu\).

Returns
\(Y_\nu\)

Definition at line 941 of file StandardModel.h.

942 {
943 return Yn;
944 }

◆ getYu()

const gslpp::matrix< gslpp::complex > & StandardModel::getYu ( ) const
inline

A get method to retrieve the Yukawa matrix of the up-type quarks, \(Y_u\).

Returns
\(Y_u\)

Definition at line 3338 of file StandardModel.h.

3339 {
3340 return Yu;
3341 }

◆ gLnuN2()

const double StandardModel::gLnuN2 ( ) const
virtual

The effective neutrino nucleon LH coupling: gLnuN2.

Follows the corresponding semianalytical expression in EWSMApproximateFormulae.

Returns
\(g_L^2(\nu N)\)

Reimplemented in NPbase.

Definition at line 3000 of file StandardModel/src/StandardModel.cpp.

3001{
3002 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
3004
3005 /* SM contribution with the approximate formula */
3007
3008 } else {
3009 throw std::runtime_error("ERROR: StandardModel::gLnuN2, prediction implemented only via semianalytical approximate formula. Check flags!");
3010 }
3011}
double LEgLnuN2Approx() const
The effective neutrino nucleon LH coupling: gLnuN2.

◆ gRnuN2()

const double StandardModel::gRnuN2 ( ) const
virtual

The effective neutrino nucleon RH coupling: gRnuN2.

Follows the corresponding semianalytical expression in EWSMApproximateFormulae.

Returns
\(g_R^2(\nu N)\)

Reimplemented in NPbase.

Definition at line 3014 of file StandardModel/src/StandardModel.cpp.

3015{
3016 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
3018
3019 /* SM contribution with the approximate formula */
3021
3022 } else {
3023 throw std::runtime_error("ERROR: StandardModel::gRnuN2, prediction implemented only via semianalytical approximate formula. Check flags!");
3024 }
3025}
double LEgRnuN2Approx() const
The effective neutrino nucleon RH coupling: gRnuN2.

◆ gV_f()

const gslpp::complex StandardModel::gV_f ( const Particle  f) const
virtual

The effective leptonic neutral-current vector coupling \(g_V^l\) in the SM.

\[ g_V^l = g_A^l (1 - 4|Q_l|\kappa_Z^l s_W^2)\,. \]

Parameters
[in]fa lepton or quark
Returns
\(g_{V,\,\mathrm{SM}}^l\)

Reimplemented in NPbase, and NPEpsilons.

Definition at line 1576 of file StandardModel/src/StandardModel.cpp.

1577{
1578 return ( gA_f(f)
1579 *(1.0 - 4.0 * fabs(f.getCharge())*(kappaZ_f(f)) * sW2()));
1580}

◆ gVnue()

const double StandardModel::gVnue ( ) const
virtual

The effective (muon) neutrino-electron vector coupling: gVnue.

Follows the corresponding semianalytical expression in EWSMApproximateFormulae.

Returns
\(g_V^{\nu_\mu e}\)

Reimplemented in NPbase.

Definition at line 3054 of file StandardModel/src/StandardModel.cpp.

3055{
3056 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
3058
3059 /* SM contribution with the approximate formula */
3061
3062 } else {
3063 throw std::runtime_error("ERROR: StandardModel::gVnue, prediction implemented only via semianalytical approximate formula. Check flags!");
3064 }
3065}
double LEgVnueApprox() const
The effective (muon) neutrino-electron vector coupling: gVnue.

◆ I_triangle_1()

gslpp::complex StandardModel::I_triangle_1 ( const double  tau,
const double  lambda 
) const

Loop function entering in the calculation of the effective \(HZ\gamma\) coupling.

Parameters
[in]

_form#4314, \(\lambda=4 M^2/m_Z^2\), with \(M\) the mass of the particle in the loop.

Returns
\(I_1(\tau,\lambda)\)

Definition at line 3277 of file StandardModel/src/StandardModel.cpp.

3277 {
3278 gslpp::complex tmp;
3279
3280 tmp = (tau * lambda * (f_triangle(tau) - f_triangle(lambda)) + 2.0 * tau * (g_triangle(tau) - g_triangle(lambda))) / (tau - lambda);
3281
3282 tmp = tau * lambda * (1.0 + tmp) / (2.0 * (tau - lambda));
3283
3284 return tmp;
3285}
gslpp::complex g_triangle(const double tau) const
Loop function entering in the calculation of the effective coupling.

◆ I_triangle_2()

gslpp::complex StandardModel::I_triangle_2 ( const double  tau,
const double  lambda 
) const

Loop function entering in the calculation of the effective \(HZ\gamma\) coupling.

Parameters
[in]

_form#4314, \(\lambda=4 M^2/m_Z^2\), with \(M\) the mass of the particle in the loop.

Returns
\(I_2(\tau,\lambda)\)

Definition at line 3287 of file StandardModel/src/StandardModel.cpp.

3287 {
3288 gslpp::complex tmp;
3289
3290 tmp = -0.5 * tau * lambda * (f_triangle(tau) - f_triangle(lambda)) / (tau - lambda);
3291
3292 return tmp;
3293}

◆ Init()

bool StandardModel::Init ( const std::map< std::string, double > &  DPars)
virtual

A method to initialize the model parameters.

Parameters
[in]DParsa map of the parameters that are being updated in the Monte Carlo run (including parameters that are varied and those that are held constant)
Returns
a boolean that is true if the execution is successful

Reimplemented from QCD.

Reimplemented in FlavourWilsonCoefficient, LoopMediators, RealWeakEFTCC, RealWeakEFTLFV, GeneralSUSY, GeorgiMachacek, LeftRightSymmetricModel, MFV, NPSMEFTd6General, pMSSM, SUSY, SUSYMassInsertion, THDM, and THDMW.

Definition at line 196 of file StandardModel/src/StandardModel.cpp.

197{
198 for (std::map<std::string, double>::const_iterator it = DPars.begin(); it != DPars.end(); it++)
199 if (it->first.compare("AlsM") == 0 || it->first.compare("MAls") == 0)
200 throw std::runtime_error("ERROR: inappropriate parameter " + it->first
201 + " in model initialization");
202 else if (FlagFixMuwMut && it->first.compare("mut") == 0)
203 throw std::runtime_error("ERROR: cannot use " + it->first
204 + " when FlagFixMuwMut is true: use only muw");
205
206 std::map<std::string, double> myDPars(DPars);
207 myDPars["AlsM"] = myDPars.at("AlsMz"); // do not change!
208 myDPars["MAls"] = myDPars.at("Mz");
209 if (FlagFixMuwMut)
210 myDPars["mut"] = myDPars.at("muw") * 163. / 80.4 ;
211 return (QCD::Init(myDPars));
212}
virtual bool Init(const std::map< std::string, double > &DPars)
Initializes the QCD parameters found in the argument.
Definition: QCD.cpp:120

◆ InitializeModel()

bool StandardModel::InitializeModel ( )
virtual

A method to initialize the model.

This method, called via InputParser::ReadParameters(), allocates memory to the pointers defined in the current class.

Returns
a boolean that is true if model initialization is successful

< A pointer to an object of type EWSMcache.

< A pointer to an object of type EWSMOneLoopEW.

< A pointer to an object of type EWSMTwoLoopQCD.

< A pointer to an object of type EWSMThreeLoopQCD.

< A pointer to an object of type EWSMTwoLoopEW.

< A pointer to an object of type EWSMThreeLoopEW2QCD.

< A pointer to an object of type EWSMThreeLoopEW.

< A pointer to an object of type EWSMApproximateFormulae.

< A pointer to an object of type EWSMTwoFermionsLEP2.

Reimplemented in FlavourWilsonCoefficient, FlavourWilsonCoefficient_DF2, LoopMediators, RealWeakEFTCC, RealWeakEFTLFV, GeneralSUSY, GeorgiMachacek, LeftRightSymmetricModel, MFV, pMSSM, SUSY, SUSYMassInsertion, THDM, and THDMW.

Definition at line 174 of file StandardModel/src/StandardModel.cpp.

175{
176 myEWSMcache = new EWSMcache(*this);
184 myLeptonFlavour = new LeptonFlavour(*this);
185 /* BEGIN: REMOVE FROM THE PACKAGE */
187 /* END: REMOVE FROM THE PACKAGE */
189 return (true);
190}
A class for approximate formulae of the EW precision observables.
A class for one-loop corrections to the EW precision observables.
A class for three-loop corrections to the EW precision observables.
A class for three-loop corrections to the EW precision observables.
A class for three-loop corrections to the EW precision observables.
A class for the form factors , and in the processes at LEP-II.
A class for two-loop corrections to the EW precision observables.
Definition: EWSMTwoLoopEW.h:57
A class for two-loop corrections to the EW precision observables.
A class for cache variables used in computing radiative corrections to the EW precision observables.
Definition: EWSMcache.h:40
The parent class in LeptonFlavour for calculating all the Wilson coefficients for various Lepton Flav...
Definition: LeptonFlavour.h:26
void setModelInitialized(bool ModelInitialized)
A set method to fix the failure or success of the initialization of the model.
Definition: Model.h:145

◆ Integrand_AFBnumeratorWithISR_l()

const double StandardModel::Integrand_AFBnumeratorWithISR_l ( double  x,
const QCD::lepton  l_flavor,
const double  s 
) const
protected

Definition at line 9290 of file StandardModel/src/StandardModel.cpp.

9291{
9292 double sprime = (1.0 - x)*s;
9293 double Ncf = 1.0;
9294 double ml = getLeptons(l_flavor).getMass();
9295 double G3prime = myTwoFermionsLEP2->G_3prime_l(l_flavor, ml, sprime, Mw(), Gamma_Z(),flagLEP2[Weak]);
9296 double H = myTwoFermionsLEP2->H_ISR_FB(x, s);
9297
9298 return ( M_PI*ale*ale*Ncf*H*G3prime/sprime );
9299}
double G_3prime_l(const QCD::lepton l, const double mf, const double s, const double Mw, const double GammaZ, const bool bWeak) const
double H_ISR_FB(const double x, const double s) const

◆ Integrand_AFBnumeratorWithISR_q()

const double StandardModel::Integrand_AFBnumeratorWithISR_q ( double  x,
const QCD::quark  q_flavor,
const double  s 
) const
protected

Definition at line 9449 of file StandardModel/src/StandardModel.cpp.

9450{
9451 double sprime = (1.0 - x)*s;
9452 double Ncf = 3.0;
9453 double mq = m_q(q_flavor, sqrt(s));
9454 double G3prime = myTwoFermionsLEP2->G_3prime_q(q_flavor, mq, sprime, Mw(), Gamma_Z(),flagLEP2[Weak]);
9455 double H = myTwoFermionsLEP2->H_ISR_FB(x, s);
9456
9457 if (flagLEP2[QCDFSR])
9458 G3prime *= myTwoFermionsLEP2->QCD_FSR_forAFB(q_flavor, mq, sprime);
9459
9460 return ( M_PI*ale*ale*Ncf*H*G3prime/sprime );
9461}
double G_3prime_q(const QCD::quark q, const double mf, const double s, const double Mw, const double GammaZ, const bool bWeak) const

◆ Integrand_dsigmaBox_l()

const double StandardModel::Integrand_dsigmaBox_l ( double  cosTheta,
const QCD::lepton  l_flavor,
const double  s 
) const
protected

Definition at line 8670 of file StandardModel/src/StandardModel.cpp.

8671{
8672 double ml = getLeptons(l_flavor).getMass();
8673 return ( myTwoFermionsLEP2->dsigma_l_box(l_flavor, ml, s, cosTheta, Mw(), Gamma_Z()) );
8674}
double dsigma_l_box(const QCD::lepton l, const double mf, const double s, const double cosTheta, const double Mw, const double GammaZ) const
An observable class for the -boson mass.
Definition: Mw.h:22

◆ Integrand_dsigmaBox_q()

const double StandardModel::Integrand_dsigmaBox_q ( double  cosTheta,
const QCD::quark  q_flavor,
const double  s 
) const
protected

Definition at line 8829 of file StandardModel/src/StandardModel.cpp.

8830{
8831 double mq = m_q(q_flavor, sqrt(s));
8832 return ( myTwoFermionsLEP2->dsigma_q_box(q_flavor, mq, s, cosTheta, Mw(), Gamma_Z()) );
8833}
double dsigma_q_box(const QCD::quark q, const double mf, const double s, const double cosTheta, const double Mw, const double GammaZ) const

◆ Integrand_sigmaWithISR_l()

const double StandardModel::Integrand_sigmaWithISR_l ( double  x,
const QCD::lepton  l_flavor,
const double  s 
) const
protected

Definition at line 8046 of file StandardModel/src/StandardModel.cpp.

8047{
8048 double sprime = (1.0 - x)*s;
8049 double ml = getLeptons(l_flavor).getMass();
8050 double l_charge = getLeptons(l_flavor).getCharge();
8051 double sigma = myTwoFermionsLEP2->sigma_l(l_flavor, ml, sprime, Mw(), Gamma_Z(),
8052 flagLEP2[Weak]);
8053 double H = myTwoFermionsLEP2->H_ISR(x, s);
8054
8055 if (!bSigmaForAFB && flagLEP2[QEDFSR])
8056 sigma *= myTwoFermionsLEP2->QED_FSR_forSigma(sprime, l_charge);
8057
8058 return ( H*sigma );
8059}
double QED_FSR_forSigma(const double s, const double Qf) const
double sigma_l(const QCD::lepton l, const double mf, const double s, const double Mw, const double GammaZ, const bool bWeak) const
double H_ISR(const double x, const double s) const

◆ Integrand_sigmaWithISR_q()

const double StandardModel::Integrand_sigmaWithISR_q ( double  x,
const QCD::quark  q_flavor,
const double  s 
) const
protected

Definition at line 8206 of file StandardModel/src/StandardModel.cpp.

8207{
8208 double sprime = (1.0 - x)*s;
8209 double mq = m_q(q_flavor, sqrt(s));
8210 double q_charge = getQuarks(q_flavor).getCharge();
8211 double sigma = myTwoFermionsLEP2->sigma_q(q_flavor, mq, sprime, Mw(), Gamma_Z(),
8212 flagLEP2[Weak]);
8213 double H = myTwoFermionsLEP2->H_ISR(x, s);
8214
8215 if (!bSigmaForAFB && flagLEP2[QEDFSR])
8216 sigma *= myTwoFermionsLEP2->QED_FSR_forSigma(sprime, q_charge);
8217
8218 if (!bSigmaForAFB && flagLEP2[QCDFSR])
8219 sigma *= myTwoFermionsLEP2->QCD_FSR_forSigma(sprime);
8220
8221 return ( H*sigma );
8222}
double sigma_q(const QCD::quark q, const double mf, const double s, const double Mw, const double GammaZ, const bool bWeak) const
double QCD_FSR_forSigma(const double s) const
const Particle & getQuarks(const QCD::quark q) const
A get method to access a quark as an object of the type Particle.
Definition: QCD.h:536

◆ intMLL2eeeeus2()

const double StandardModel::intMLL2eeeeus2 ( const double  s,
const double  t0,
const double  t1 
) const

Definition at line 3966 of file StandardModel/src/StandardModel.cpp.

3966 {
3967
3968 double intM2;
3969 double sw2cw2;
3970 double gLeSM;
3971 double GammaZSM;
3972 double Mz2, Mz4, s2;
3973
3974 sw2cw2 = s02() * c02();
3975 gLeSM = (leptons[ELECTRON].getIsospin()) - (leptons[ELECTRON].getCharge()) * s02();
3976 GammaZSM = Gamma_Z();
3977 Mz2 = Mz * Mz;
3978 Mz4 = Mz2 * Mz2;
3979 s2 = s * s;
3980
3981 intM2 = (gLeSM*gLeSM*gLeSM*gLeSM*s2 + 2.0*gLeSM*gLeSM*s*(-Mz2 + s)*sw2cw2 + sw2cw2*sw2cw2*(Mz4 + s2 + Mz2*(-2.0*s + GammaZSM*GammaZSM)))/(3.0*s2*sw2cw2*sw2cw2*(Mz4 + s2 + Mz2*(-2.0*s + GammaZSM*GammaZSM)))*(pow(s + t1,3.0) - pow(s + t0,3.0)) +
3982 ((2.0*(1.0 + (gLeSM*gLeSM*s*(-Mz2 + s))/(sw2cw2*(Mz4 + s2 + Mz2*(-2.0*s + GammaZSM*GammaZSM)))) )/s)*(2.0*s *(t1 - t0) + (t1*t1 - t0*t0)/2.0 + s2*log(t1/t0)) +
3983 (2.0*gLeSM*gLeSM* (-sw2cw2 + (gLeSM*gLeSM*(Mz2 - s)*s)/(Mz4 + s2 + Mz2*(-2.0*s + GammaZSM*GammaZSM))))/(s*sw2cw2*sw2cw2)* (-(1.0/2.0)*t1*(2.0*Mz2 + 4.0*s + t1) + (1.0/2.0)*t0*(2.0*Mz2 + 4.0*s + t0) - (Mz2 + s)*(Mz2 + s)*log((-Mz2 + t1)/(-Mz2 + t0)) ) +
3984 (2.0*(gLeSM*gLeSM) )/(Mz2*sw2cw2)*(Mz2 *(t1 - t0) - s2*log(t1/t0) + (Mz2 + s)*(Mz2 + s)*log((-Mz2 + t1)/(-Mz2 + t0))) +
3985 (-(s2/t1) + s2/t0 + t1 - t0 + 2.0*s*log(t1/t0)) +
3986 (gLeSM*gLeSM*gLeSM*gLeSM /sw2cw2/sw2cw2)*((Mz2 + s)*(Mz2 + s)*(1.0/(Mz2 - t1) - 1.0/(Mz2 - t0)) + t1 - t0 + 2.0*(Mz2 + s)*log((-Mz2 + t1)/(-Mz2 + t0)));
3987
3988 return intM2;
3989}

◆ intMLR2eeeets2()

const double StandardModel::intMLR2eeeets2 ( const double  s,
const double  t0,
const double  t1 
) const

Definition at line 3922 of file StandardModel/src/StandardModel.cpp.

3922 {
3923
3924 double intM2;
3925 double sw2cw2;
3926 double gLeSM,gReSM;
3927 double GammaZSM;
3928 double Mz2, s2;
3929 double propZSM2,propZSMRe,MeeLR2SM;
3930
3931 sw2cw2 = s02() * c02();
3932 gLeSM = (leptons[ELECTRON].getIsospin()) - (leptons[ELECTRON].getCharge()) * s02();
3933 gReSM = - (leptons[ELECTRON].getCharge()) * s02();
3934 GammaZSM = Gamma_Z();
3935 Mz2 = Mz * Mz;
3936 s2 = s * s;
3937
3938 propZSM2 = s2/((s - Mz2)*(s - Mz2) + Mz2*GammaZSM*GammaZSM);
3939 propZSMRe = (s*(s - Mz2))/((s - Mz2)*(s - Mz2) + Mz2*GammaZSM*GammaZSM);
3940
3941 MeeLR2SM = 1.0 + (gLeSM*gLeSM*gReSM*gReSM/(sw2cw2*sw2cw2))*propZSM2 + 2.0*(gLeSM*gReSM/sw2cw2)*propZSMRe;
3942
3943 intM2 = MeeLR2SM*(t1*t1*t1 - t0*t0*t0)/(3.0*s*s);
3944
3945 return intM2;
3946}

◆ intMLRtilde2eeeest2()

const double StandardModel::intMLRtilde2eeeest2 ( const double  s,
const double  t0,
const double  t1 
) const

Definition at line 3948 of file StandardModel/src/StandardModel.cpp.

3948 {
3949
3950 double intM2;
3951 double sw2cw2;
3952 double gLeSM,gReSM;
3953 double Mz2;
3954
3955 sw2cw2 = s02() * c02();
3956 gLeSM = (leptons[ELECTRON].getIsospin()) - (leptons[ELECTRON].getCharge()) * s02();
3957 gReSM = - (leptons[ELECTRON].getCharge()) * s02();
3958 Mz2 = Mz * Mz;
3959
3960 intM2 = s*s*(((gLeSM*gLeSM*gReSM*gReSM)/sw2cw2/sw2cw2)*(1.0/(Mz2 - t1) - 1.0/(Mz2 - t0)) - 1.0/t1 + 1.0/t0 +
3961 (2.0*gLeSM*gReSM*(-log(t1/t0) + log((-Mz2 + t1)/(-Mz2 + t0))))/(Mz2*sw2cw2));
3962
3963 return intM2;
3964}

◆ intMRR2eeeeus2()

const double StandardModel::intMRR2eeeeus2 ( const double  s,
const double  t0,
const double  t1 
) const

Definition at line 3991 of file StandardModel/src/StandardModel.cpp.

3991 {
3992
3993 double intM2;
3994 double sw2cw2;
3995 double gReSM;
3996 double GammaZSM;
3997 double Mz2, Mz4, s2;
3998
3999 sw2cw2 = s02() * c02();
4000 gReSM = - (leptons[ELECTRON].getCharge()) * s02();
4001 GammaZSM = Gamma_Z();
4002 Mz2 = Mz * Mz;
4003 Mz4 = Mz2 * Mz2;
4004 s2 = s * s;
4005
4006 intM2 = (gReSM*gReSM*gReSM*gReSM*s2 + 2.0*gReSM*gReSM*s*(-Mz2 + s)*sw2cw2 + sw2cw2*sw2cw2*(Mz4 + s2 + Mz2*(-2.0*s + GammaZSM*GammaZSM)))/(3.0*s2*sw2cw2*sw2cw2*(Mz4 + s2 + Mz2*(-2.0*s + GammaZSM*GammaZSM)))*(pow(s + t1,3.0) - pow(s + t0,3.0)) +
4007 ((2.0*(1.0 + (gReSM*gReSM*s*(-Mz2 + s))/(sw2cw2*(Mz4 + s2 + Mz2*(-2.0*s + GammaZSM*GammaZSM)))) )/s)*(2.0*s *(t1 - t0) + (t1*t1 - t0*t0)/2.0 + s2*log(t1/t0)) +
4008 (2.0*gReSM*gReSM* (-sw2cw2 + (gReSM*gReSM*(Mz2 - s)*s)/(Mz4 + s2 + Mz2*(-2.0*s + GammaZSM*GammaZSM))))/(s*sw2cw2*sw2cw2)* (-(1.0/2.0)*t1*(2.0*Mz2 + 4.0*s + t1) + (1.0/2.0)*t0*(2.0*Mz2 + 4.0*s + t0) - (Mz2 + s)*(Mz2 + s)*log((-Mz2 + t1)/(-Mz2 + t0)) ) +
4009 (2.0*(gReSM*gReSM) )/(Mz2*sw2cw2)*(Mz2 *(t1 - t0) - s2*log(t1/t0) + (Mz2 + s)*(Mz2 + s)*log((-Mz2 + t1)/(-Mz2 + t0))) +
4010 (-(s2/t1) + s2/t0 + t1 - t0 + 2.0*s*log(t1/t0)) +
4011 (gReSM*gReSM*gReSM*gReSM /sw2cw2/sw2cw2)*((Mz2 + s)*(Mz2 + s)*(1.0/(Mz2 - t1) - 1.0/(Mz2 - t0)) + t1 - t0 + 2.0*(Mz2 + s)*log((-Mz2 + t1)/(-Mz2 + t0)));
4012
4013 return intM2;
4014}

◆ IsFlagNoApproximateGammaZ()

const bool StandardModel::IsFlagNoApproximateGammaZ ( ) const
inline

A method to retrieve the model flag NoApproximateGammaZ.

See StandardModelFlags for detail.

Returns
a boolean that is true if the two-loop approximate formulae of the partial and total decay widths of the \(Z\) boson defined with the function EWSMApproximateFormulae::X_full_2_loop() is NOT employed

Definition at line 679 of file StandardModel.h.

680 {
682 }

◆ IsFlagWithoutNonUniversalVC()

const bool StandardModel::IsFlagWithoutNonUniversalVC ( ) const
inline

A method to retrieve the model flag WithoutNonUniversalVC.

See StandardModelFlags for detail.

Returns
a boolean that is true if flavour non-universal vertex corrections are NOT added to the epsilon parameters describing new physics contribution
Attention
The flag FlagWithoutNonUniversalVC is applicable only for the models StandardModel and NPEpsilons.

Definition at line 666 of file StandardModel.h.

667 {
669 }

◆ kappaZ_f()

const gslpp::complex StandardModel::kappaZ_f ( const Particle  f) const
virtual

The effective leptonic neutral-current coupling \(\kappa_Z^l\) in the SM.

This function collects the radiative corrections to \(\kappa_Z^l\) computed via EWSMOneLoopEW, EWSMTwoLoopQCD, EWSMTwoLoopEW, EWSMThreeLoopQCD, EWSMThreeLoopEW2QCD and EWSMThreeLoopEW classes. The real part is computed with the function resumKappaZ(), while only the one-loop contribution is kept in the imaginary part.

As a part of the two-loop EW contribution, a correction associated with the product of the imaginary part of \(\Delta\alpha\) and that of \(\Pi_{Z\gamma}\) is included [Bardin:1999ak], [Bardin:1999yd] :

\begin{eqnarray} \Delta \kappa_Z^l = - \frac{1}{s_W^2}\left( \frac{\alpha(M_Z^2)}{4\pi} \right)^2 {\rm Im}\,\overline{\Pi}_{\gamma\gamma}^{\rm fer}(M_Z^2)\,\, {\rm Im}\,\overline{\Pi}_{Z\gamma}^{\rm fer}(M_Z^2) = \frac{35\alpha^2(M_Z^2)}{18 s_W^2}\, \left( 1 - \frac{8}{3}\, {\rm Re}(\kappa_Z^l) s_W^2 \right). \end{eqnarray}

Parameters
[in]fa lepton or quark
Returns
\(\kappa_{Z,\,\mathrm{SM}}^l\)
See also
resumKappaZ()
Attention
If the model flag CacheInStandardModel of StandardModel is set to true, the caching method implemented in the current class is employed.

Reimplemented in NPbase, and NPEpsilons.

Definition at line 1652 of file StandardModel/src/StandardModel.cpp.

1653{
1654 if (f.is("TOP")) return (gslpp::complex(0.0, 0.0, false));
1655
1657 if (useKappaZ_f_cache[f.getIndex()])
1658 return kappaZ_f_cache[f.getIndex()];
1659
1660 double myMw = Mw();
1661
1662 double ReKappaZf = 0.0, ImKappaZf = 0.0;
1663 if (FlagKappaZ.compare("APPROXIMATEFORMULA") == 0) {
1664
1665// Choose the correct formulae for the effective angle
1666 if ( f.is("BOTTOM") ){
1667 ReKappaZf = myApproximateFormulae->sin2thetaEff_b_full() / sW2();
1668 } else if ( f.is("ELECTRON") || f.is("MU") || f.is("TAU") ) {
1669 ReKappaZf = myApproximateFormulae->sin2thetaEff_l_full() / sW2();
1670 } else {
1671 ReKappaZf = myApproximateFormulae->sin2thetaEff(f) / sW2();
1672 }
1673
1674 ImKappaZf = myOneLoopEW->deltaKappa_rem_f(f, myMw).imag();
1675#ifdef WITHIMTWOLOOPQCD
1676 ImKappaZf += myTwoLoopQCD->deltaKappa_rem_f(f, myMw).imag();
1677
1678 /* TEST */
1679 //ImKappaZf -= myCache->ale()*myCache->alsMz()/24.0/M_PI*(cW2() - sW2())/sW2()/sW2();
1680#endif
1681 } else {
1682 /* compute Delta rho */
1683 double DeltaRho[orders_EW_size];
1684 ComputeDeltaRho(myMw, DeltaRho);
1685
1686 /* compute delta kappa_rem^f */
1687 gslpp::complex deltaKappa_remf[orders_EW_size];
1688 deltaKappa_remf[EW1] = gslpp::complex(0.0, 0.0, false);
1689 deltaKappa_remf[EW1QCD1] = gslpp::complex(0.0, 0.0, false);
1690 deltaKappa_remf[EW1QCD2] = gslpp::complex(0.0, 0.0, false);
1691 deltaKappa_remf[EW2] = gslpp::complex(0.0, 0.0, false);
1692 deltaKappa_remf[EW2QCD1] = gslpp::complex(0.0, 0.0, false);
1693 deltaKappa_remf[EW3] = gslpp::complex(0.0, 0.0, false);
1694 if (flag_order[EW1])
1695 deltaKappa_remf[EW1] = myOneLoopEW->deltaKappa_rem_f(f, myMw);
1696 if (flag_order[EW1QCD1])
1697#ifdef WITHIMTWOLOOPQCD
1698 deltaKappa_remf[EW1QCD1] = gslpp::complex(myTwoLoopQCD->deltaKappa_rem_f(f, myMw).real(),
1699 myTwoLoopQCD->deltaKappa_rem_f(f, myMw).imag(), false);
1700#else
1701 deltaKappa_remf[EW1QCD1] = gslpp::complex(myTwoLoopQCD->deltaKappa_rem_f(f, myMw).real(), 0.0, false);
1702#endif
1703 if (flag_order[EW1QCD2])
1704 deltaKappa_remf[EW1QCD2] = gslpp::complex(myThreeLoopQCD->deltaKappa_rem_f(f, myMw).real(), 0.0, false);
1705 if (flag_order[EW2])
1706 deltaKappa_remf[EW2] = gslpp::complex(myTwoLoopEW->deltaKappa_rem_f(f, myMw).real(), 0.0, false);
1707 if (flag_order[EW2QCD1])
1708 deltaKappa_remf[EW2QCD1] = gslpp::complex(myThreeLoopEW2QCD->deltaKappa_rem_f(f, myMw).real(), 0.0, false);
1709 if (flag_order[EW3])
1710 deltaKappa_remf[EW3] = gslpp::complex(myThreeLoopEW->deltaKappa_rem_f(f, myMw).real(), 0.0, false);
1711
1712 /* compute Delta rbar_rem */
1713 double DeltaRbar_rem = 0.0;
1714 if (flag_order[EW1])
1715 DeltaRbar_rem = myOneLoopEW->DeltaRbar_rem(myMw);
1716
1717 /* Re[kappa_Z^f] with or without resummation */
1718 double deltaKappa_rem_f_real[orders_EW_size];
1719 for (int j = 0; j < orders_EW_size; ++j)
1720 deltaKappa_rem_f_real[j] = deltaKappa_remf[j].real();
1721
1722 ReKappaZf = resumKappaZ(DeltaRho, deltaKappa_rem_f_real, DeltaRbar_rem, f.is("BOTTOM"));
1723
1724 /* O(alpha^2) correction to Re[kappa_Z^f] from the Z-gamma mixing */
1725 ReKappaZf += 35.0 * alphaMz() * alphaMz() / 18.0 / sW2()
1726 *(1.0 - 8.0 / 3.0 * ReKappaZf * sW2());
1727
1728 /* Im[kappa_Z^f] without resummation */
1729 for (int j = 0; j < orders_EW_size; ++j)
1730 ImKappaZf += deltaKappa_remf[j].imag();
1731 }
1732
1733 kappaZ_f_cache[f.getIndex()] = gslpp::complex(ReKappaZf, ImKappaZf, false);
1734 useKappaZ_f_cache[f.getIndex()] = true;
1735 return (gslpp::complex(ReKappaZf, ImKappaZf, false));
1736}
double sin2thetaEff(const Particle p) const
The value of the effective weak mixing anlge for a given fermion.
double sin2thetaEff_b_full() const
with the full two-loop EW corrections.
double sin2thetaEff_l_full() const
with the full two-loop EW corrections.
gslpp::complex deltaKappa_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
double DeltaRbar_rem(const double Mw_i) const
.
gslpp::complex deltaKappa_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
gslpp::complex deltaKappa_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
gslpp::complex deltaKappa_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
gslpp::complex deltaKappa_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
gslpp::complex deltaKappa_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
void ComputeDeltaRho(const double Mw_i, double DeltaRho[orders_EW_size]) const
A method to collect computed via subclasses.
double resumKappaZ(const double DeltaRho[orders_EW_size], const double deltaKappa_rem[orders_EW_size], const double DeltaRbar_rem, const bool bool_Zbb) const
A method to compute the real part of the effetvive coupling from , and .

◆ LEP2AFBbottom()

const double StandardModel::LEP2AFBbottom ( const double  s) const
virtual

Reimplemented in NPbase, and NPSTUVWXY.

Definition at line 6156 of file StandardModel/src/StandardModel.cpp.

6157{
6158
6159 bSigmaForAFB = true;
6160 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
6161 double relerr = 1.e-7;
6162 double abserr = 1.e-17;
6163
6164 if(s == 133.*133.){
6165 double AFB_noBox, sigma = 0.0;
6166 if (!flagLEP2[ISR])
6167 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6168 else {
6169 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom133, &(*this), _1));
6170 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6171 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6172 }
6173 double numerator = average; // interval
6174
6175
6176 sigma = LEP2sigmaBottom(s);
6177
6178 AFB_noBox = numerator/sigma;
6179 }
6180 SMresult_cache = AFB_noBox;
6181
6182 if (flagLEP2[WeakBox]) {
6183 // numerator
6184 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom133, &(*this), _1));
6185 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6186 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6187 }
6188 double sigma_box_F = average; // interval
6189 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom133, &(*this), _1));
6190 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6191 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6192 }
6193 double sigma_box_B = average; // interval
6194
6195 // denominator
6196 if (!flagLEP2[ISR]) {
6197
6198 sigma = LEP2sigmaBottom(s);
6199 }
6200
6201 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6202 }
6203 } else if (s == 167.*167.){
6204 double AFB_noBox, sigma = 0.0;
6205 if (!flagLEP2[ISR])
6206 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6207 else {
6208 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom167, &(*this), _1));
6209 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6210 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6211 }
6212 double numerator = average; // interval
6213
6214
6215 sigma = LEP2sigmaBottom(s);
6216
6217 AFB_noBox = numerator/sigma;
6218 }
6219 SMresult_cache = AFB_noBox;
6220
6221 if (flagLEP2[WeakBox]) {
6222 // numerator
6223 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom167, &(*this), _1));
6224 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6225 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6226 }
6227 double sigma_box_F = average; // interval
6228 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom167, &(*this), _1));
6229 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6230 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6231 }
6232 double sigma_box_B = average; // interval
6233
6234 // denominator
6235 if (!flagLEP2[ISR]) {
6236
6237 sigma = LEP2sigmaBottom(s);
6238 }
6239
6240 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6241 }
6242 } else if (s == 183.*183.) {
6243 double AFB_noBox, sigma = 0.0;
6244 if (!flagLEP2[ISR])
6245 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6246 else {
6247 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom183, &(*this), _1));
6248 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6249 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6250 }
6251 double numerator = average; // interval
6252
6253
6254 sigma = LEP2sigmaBottom(s);
6255
6256 AFB_noBox = numerator/sigma;
6257 }
6258 SMresult_cache = AFB_noBox;
6259
6260 if (flagLEP2[WeakBox]) {
6261 // numerator
6262 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom183, &(*this), _1));
6263 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6264 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6265 }
6266 double sigma_box_F = average; // interval
6267 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom183, &(*this), _1));
6268 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6269 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6270 }
6271 double sigma_box_B = average; // interval
6272
6273 // denominator
6274 if (!flagLEP2[ISR]) {
6275
6276 sigma = LEP2sigmaBottom(s);
6277 }
6278
6279 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6280 }
6281 } else if (s == 189.*189.) {
6282 double AFB_noBox, sigma = 0.0;
6283 if (!flagLEP2[ISR])
6284 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6285 else {
6286 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom189, &(*this), _1));
6287 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6288 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6289 }
6290 double numerator = average; // interval
6291
6292
6293 sigma = LEP2sigmaBottom(s);
6294
6295 AFB_noBox = numerator/sigma;
6296 }
6297 SMresult_cache = AFB_noBox;
6298
6299 if (flagLEP2[WeakBox]) {
6300 // numerator
6301 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom189, &(*this), _1));
6302 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6303 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6304 }
6305 double sigma_box_F = average; // interval
6306 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom189, &(*this), _1));
6307 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6308 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6309 }
6310 double sigma_box_B = average; // interval
6311
6312 // denominator
6313 if (!flagLEP2[ISR]) {
6314
6315 sigma = LEP2sigmaBottom(s);
6316 }
6317
6318 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6319 }
6320 } else if (s == 192.*192.) {
6321 double AFB_noBox, sigma = 0.0;
6322 if (!flagLEP2[ISR])
6323 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6324 else {
6325 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom192, &(*this), _1));
6326 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6327 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6328 }
6329 double numerator = average; // interval
6330
6331
6332 sigma = LEP2sigmaBottom(s);
6333
6334 AFB_noBox = numerator/sigma;
6335 }
6336 SMresult_cache = AFB_noBox;
6337
6338 if (flagLEP2[WeakBox]) {
6339 // numerator
6340 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom192, &(*this), _1));
6341 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6342 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6343 }
6344 double sigma_box_F = average; // interval
6345 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom192, &(*this), _1));
6346 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6347 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6348 }
6349 double sigma_box_B = average; // interval
6350
6351 // denominator
6352 if (!flagLEP2[ISR]) {
6353
6354 sigma = LEP2sigmaBottom(s);
6355 }
6356
6357 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6358 }
6359 } else if (s == 196.*196.) {
6360 double AFB_noBox, sigma = 0.0;
6361 if (!flagLEP2[ISR])
6362 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6363 else {
6364 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom196, &(*this), _1));
6365 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6366 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6367 }
6368 double numerator = average; // interval
6369
6370
6371 sigma = LEP2sigmaBottom(s);
6372
6373 AFB_noBox = numerator/sigma;
6374 }
6375 SMresult_cache = AFB_noBox;
6376
6377 if (flagLEP2[WeakBox]) {
6378 // numerator
6379 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom196, &(*this), _1));
6380 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6381 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6382 }
6383 double sigma_box_F = average; // interval
6384 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom196, &(*this), _1));
6385 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6386 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6387 }
6388 double sigma_box_B = average; // interval
6389
6390 // denominator
6391 if (!flagLEP2[ISR]) {
6392
6393 sigma = LEP2sigmaBottom(s);
6394 }
6395
6396 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6397 }
6398 } else if (s == 200.*200.) {
6399 double AFB_noBox, sigma = 0.0;
6400 if (!flagLEP2[ISR])
6401 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6402 else {
6403 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom200, &(*this), _1));
6404 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6405 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6406 }
6407 double numerator = average; // interval
6408
6409
6410 sigma = LEP2sigmaBottom(s);
6411
6412 AFB_noBox = numerator/sigma;
6413 }
6414 SMresult_cache = AFB_noBox;
6415
6416 if (flagLEP2[WeakBox]) {
6417 // numerator
6418 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom200, &(*this), _1));
6419 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6420 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6421 }
6422 double sigma_box_F = average; // interval
6423 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom200, &(*this), _1));
6424 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6425 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6426 }
6427 double sigma_box_B = average; // interval
6428
6429 // denominator
6430 if (!flagLEP2[ISR]) {
6431
6432 sigma = LEP2sigmaBottom(s);
6433 }
6434
6435 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6436 }
6437 } else if (s == 202.*202.) {
6438 double AFB_noBox, sigma = 0.0;
6439 if (!flagLEP2[ISR])
6440 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6441 else {
6442 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom202, &(*this), _1));
6443 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6444 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6445 }
6446 double numerator = average; // interval
6447
6448
6449 sigma = LEP2sigmaBottom(s);
6450
6451 AFB_noBox = numerator/sigma;
6452 }
6453 SMresult_cache = AFB_noBox;
6454
6455 if (flagLEP2[WeakBox]) {
6456 // numerator
6457 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom202, &(*this), _1));
6458 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6459 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6460 }
6461 double sigma_box_F = average; // interval
6462 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom202, &(*this), _1));
6463 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6464 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6465 }
6466 double sigma_box_B = average; // interval
6467
6468 // denominator
6469 if (!flagLEP2[ISR]) {
6470
6471 sigma = LEP2sigmaBottom(s);
6472 }
6473
6474 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6475 }
6476 } else if (s == 205.*205.) {
6477 double AFB_noBox, sigma = 0.0;
6478 if (!flagLEP2[ISR])
6479 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6480 else {
6481 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom205, &(*this), _1));
6482 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6483 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6484 }
6485 double numerator = average; // interval
6486
6487
6488 sigma = LEP2sigmaBottom(s);
6489
6490 AFB_noBox = numerator/sigma;
6491 }
6492 SMresult_cache = AFB_noBox;
6493
6494 if (flagLEP2[WeakBox]) {
6495 // numerator
6496 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom205, &(*this), _1));
6497 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6498 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6499 }
6500 double sigma_box_F = average; // interval
6501 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom205, &(*this), _1));
6502 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6503 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6504 }
6505 double sigma_box_B = average; // interval
6506
6507 // denominator
6508 if (!flagLEP2[ISR]) {
6509
6510 sigma = LEP2sigmaBottom(s);
6511 }
6512
6513 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6514 }
6515 } else if (s == 207.*207.) {
6516 double AFB_noBox, sigma = 0.0;
6517 if (!flagLEP2[ISR])
6518 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6519 else {
6520 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom207, &(*this), _1));
6521 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6522 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6523 }
6524 double numerator = average; // interval
6525
6526
6527 sigma = LEP2sigmaBottom(s);
6528
6529 AFB_noBox = numerator/sigma;
6530 }
6531 SMresult_cache = AFB_noBox;
6532
6533 if (flagLEP2[WeakBox]) {
6534 // numerator
6535 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom207, &(*this), _1));
6536 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6537 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6538 }
6539 double sigma_box_F = average; // interval
6540 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom207, &(*this), _1));
6541 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6542 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6543 }
6544 double sigma_box_B = average; // interval
6545
6546 // denominator
6547 if (!flagLEP2[ISR]) {
6548
6549 sigma = LEP2sigmaBottom(s);
6550 }
6551
6552 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6553 }
6554 } else {
6555 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2AFBbottom!");
6556 }
6557
6558 double AFBbottom = SMresult_cache;
6559
6560 gsl_set_error_handler(old_handler);
6561 bSigmaForAFB = false;
6562 return AFBbottom;
6563
6564}
An observable class for the forward-backward asymmetry in at the pole.
Definition: AFBbottom.h:39
const double getIntegrand_AFBnumeratorWithISR_bottom192(double x) const
const double getIntegrand_AFBnumeratorWithISR_bottom196(double x) const
gsl_function f_GSL
const double getIntegrand_dsigmaBox_bottom189(double x) const
const double getIntegrand_dsigmaBox_bottom207(double x) const
double SMresult_cache
const double getIntegrand_dsigmaBox_bottom202(double x) const
const double getIntegrand_dsigmaBox_bottom200(double x) const
const double getIntegrand_dsigmaBox_bottom205(double x) const
const double getIntegrand_dsigmaBox_bottom183(double x) const
const double getIntegrand_AFBnumeratorWithISR_bottom207(double x) const
const double getIntegrand_AFBnumeratorWithISR_bottom200(double x) const
const double getIntegrand_dsigmaBox_bottom196(double x) const
const double getIntegrand_AFBnumeratorWithISR_bottom205(double x) const
const double getIntegrand_AFBnumeratorWithISR_bottom189(double x) const
const double AFB_NoISR_q(const QCD::quark q_flavor, const double s) const
const double getIntegrand_dsigmaBox_bottom133(double x) const
const double getIntegrand_dsigmaBox_bottom167(double x) const
const double getIntegrand_AFBnumeratorWithISR_bottom202(double x) const
const double getIntegrand_dsigmaBox_bottom192(double x) const
const double getIntegrand_AFBnumeratorWithISR_bottom167(double x) const
const double getIntegrand_AFBnumeratorWithISR_bottom133(double x) const
virtual const double LEP2sigmaBottom(const double s) const
const double getIntegrand_AFBnumeratorWithISR_bottom183(double x) const

◆ LEP2AFBcharm()

const double StandardModel::LEP2AFBcharm ( const double  s) const
virtual

Reimplemented in NPbase, and NPSTUVWXY.

Definition at line 6567 of file StandardModel/src/StandardModel.cpp.

6568{
6569
6570 bSigmaForAFB = true;
6571 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
6572 double relerr = 1.e-7;
6573 double abserr = 1.e-17;
6574
6575 if(s == 133.*133.){
6576 double AFB_noBox, sigma = 0.0;
6577 if (!flagLEP2[ISR])
6578 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6579 else {
6580 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm133, &(*this), _1));
6581 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6582 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6583 }
6584 double numerator = average; // interval
6585
6586
6587 sigma = LEP2sigmaCharm(s);
6588
6589 AFB_noBox = numerator/sigma;
6590 }
6591 SMresult_cache = AFB_noBox;
6592
6593 if (flagLEP2[WeakBox]) {
6594 // numerator
6595 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm133, &(*this), _1));
6596 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6597 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6598 }
6599 double sigma_box_F = average; // interval
6600 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm133, &(*this), _1));
6601 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6602 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6603 }
6604 double sigma_box_B = average; // interval
6605
6606 // denominator
6607 if (!flagLEP2[ISR]) {
6608
6609 sigma = LEP2sigmaCharm(s);
6610 }
6611
6612 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6613 }
6614 } else if (s == 167.*167.){
6615 double AFB_noBox, sigma = 0.0;
6616 if (!flagLEP2[ISR])
6617 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6618 else {
6619 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm167, &(*this), _1));
6620 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6621 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6622 }
6623 double numerator = average; // interval
6624
6625
6626 sigma = LEP2sigmaCharm(s);
6627
6628 AFB_noBox = numerator/sigma;
6629 }
6630 SMresult_cache = AFB_noBox;
6631
6632 if (flagLEP2[WeakBox]) {
6633 // numerator
6634 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm167, &(*this), _1));
6635 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6636 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6637 }
6638 double sigma_box_F = average; // interval
6639 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm167, &(*this), _1));
6640 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6641 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6642 }
6643 double sigma_box_B = average; // interval
6644
6645 // denominator
6646 if (!flagLEP2[ISR]) {
6647
6648 sigma = LEP2sigmaCharm(s);
6649 }
6650
6651 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6652 }
6653 } else if (s == 183.*183.) {
6654 double AFB_noBox, sigma = 0.0;
6655 if (!flagLEP2[ISR])
6656 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6657 else {
6658 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm183, &(*this), _1));
6659 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6660 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6661 }
6662 double numerator = average; // interval
6663
6664
6665 sigma = LEP2sigmaCharm(s);
6666
6667 AFB_noBox = numerator/sigma;
6668 }
6669 SMresult_cache = AFB_noBox;
6670
6671 if (flagLEP2[WeakBox]) {
6672 // numerator
6673 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm183, &(*this), _1));
6674 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6675 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6676 }
6677 double sigma_box_F = average; // interval
6678 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm183, &(*this), _1));
6679 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6680 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6681 }
6682 double sigma_box_B = average; // interval
6683
6684 // denominator
6685 if (!flagLEP2[ISR]) {
6686
6687 sigma = LEP2sigmaCharm(s);
6688 }
6689
6690 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6691 }
6692 } else if (s == 189.*189.) {
6693 double AFB_noBox, sigma = 0.0;
6694 if (!flagLEP2[ISR])
6695 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6696 else {
6697 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm189, &(*this), _1));
6698 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6699 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6700 }
6701 double numerator = average; // interval
6702
6703
6704 sigma = LEP2sigmaCharm(s);
6705
6706 AFB_noBox = numerator/sigma;
6707 }
6708 SMresult_cache = AFB_noBox;
6709
6710 if (flagLEP2[WeakBox]) {
6711 // numerator
6712 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm189, &(*this), _1));
6713 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6714 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6715 }
6716 double sigma_box_F = average; // interval
6717 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm189, &(*this), _1));
6718 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6719 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6720 }
6721 double sigma_box_B = average; // interval
6722
6723 // denominator
6724 if (!flagLEP2[ISR]) {
6725
6726 sigma = LEP2sigmaCharm(s);
6727 }
6728
6729 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6730 }
6731 } else if (s == 192.*192.) {
6732 double AFB_noBox, sigma = 0.0;
6733 if (!flagLEP2[ISR])
6734 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6735 else {
6736 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm192, &(*this), _1));
6737 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6738 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6739 }
6740 double numerator = average; // interval
6741
6742
6743 sigma = LEP2sigmaCharm(s);
6744
6745 AFB_noBox = numerator/sigma;
6746 }
6747 SMresult_cache = AFB_noBox;
6748
6749 if (flagLEP2[WeakBox]) {
6750 // numerator
6751 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm192, &(*this), _1));
6752 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6753 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6754 }
6755 double sigma_box_F = average; // interval
6756 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm192, &(*this), _1));
6757 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6758 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6759 }
6760 double sigma_box_B = average; // interval
6761
6762 // denominator
6763 if (!flagLEP2[ISR]) {
6764
6765 sigma = LEP2sigmaCharm(s);
6766 }
6767
6768 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6769 }
6770 } else if (s == 196.*196.) {
6771 double AFB_noBox, sigma = 0.0;
6772 if (!flagLEP2[ISR])
6773 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6774 else {
6775 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm196, &(*this), _1));
6776 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6777 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6778 }
6779 double numerator = average; // interval
6780
6781
6782 sigma = LEP2sigmaCharm(s);
6783
6784 AFB_noBox = numerator/sigma;
6785 }
6786 SMresult_cache = AFB_noBox;
6787
6788 if (flagLEP2[WeakBox]) {
6789 // numerator
6790 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm196, &(*this), _1));
6791 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6792 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6793 }
6794 double sigma_box_F = average; // interval
6795 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm196, &(*this), _1));
6796 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6797 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6798 }
6799 double sigma_box_B = average; // interval
6800
6801 // denominator
6802 if (!flagLEP2[ISR]) {
6803
6804 sigma = LEP2sigmaCharm(s);
6805 }
6806
6807 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6808 }
6809 } else if (s == 200.*200.) {
6810 double AFB_noBox, sigma = 0.0;
6811 if (!flagLEP2[ISR])
6812 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6813 else {
6814 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm200, &(*this), _1));
6815 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6816 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6817 }
6818 double numerator = average; // interval
6819
6820
6821 sigma = LEP2sigmaCharm(s);
6822
6823 AFB_noBox = numerator/sigma;
6824 }
6825 SMresult_cache = AFB_noBox;
6826
6827 if (flagLEP2[WeakBox]) {
6828 // numerator
6829 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm200, &(*this), _1));
6830 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6831 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6832 }
6833 double sigma_box_F = average; // interval
6834 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm200, &(*this), _1));
6835 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6836 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6837 }
6838 double sigma_box_B = average; // interval
6839
6840 // denominator
6841 if (!flagLEP2[ISR]) {
6842
6843 sigma = LEP2sigmaCharm(s);
6844 }
6845
6846 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6847 }
6848 } else if (s == 202.*202.) {
6849 double AFB_noBox, sigma = 0.0;
6850 if (!flagLEP2[ISR])
6851 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6852 else {
6853 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm202, &(*this), _1));
6854 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6855 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6856 }
6857 double numerator = average; // interval
6858
6859
6860 sigma = LEP2sigmaCharm(s);
6861
6862 AFB_noBox = numerator/sigma;
6863 }
6864 SMresult_cache = AFB_noBox;
6865
6866 if (flagLEP2[WeakBox]) {
6867 // numerator
6868 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm202, &(*this), _1));
6869 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6870 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6871 }
6872 double sigma_box_F = average; // interval
6873 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm202, &(*this), _1));
6874 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6875 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6876 }
6877 double sigma_box_B = average; // interval
6878
6879 // denominator
6880 if (!flagLEP2[ISR]) {
6881
6882 sigma = LEP2sigmaCharm(s);
6883 }
6884
6885 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6886 }
6887 } else if (s == 205.*205.) {
6888 double AFB_noBox, sigma = 0.0;
6889 if (!flagLEP2[ISR])
6890 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6891 else {
6892 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm205, &(*this), _1));
6893 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6894 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6895 }
6896 double numerator = average; // interval
6897
6898
6899 sigma = LEP2sigmaCharm(s);
6900
6901 AFB_noBox = numerator/sigma;
6902 }
6903 SMresult_cache = AFB_noBox;
6904
6905 if (flagLEP2[WeakBox]) {
6906 // numerator
6907 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm205, &(*this), _1));
6908 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6909 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6910 }
6911 double sigma_box_F = average; // interval
6912 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm205, &(*this), _1));
6913 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6914 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6915 }
6916 double sigma_box_B = average; // interval
6917
6918 // denominator
6919 if (!flagLEP2[ISR]) {
6920
6921 sigma = LEP2sigmaCharm(s);
6922 }
6923
6924 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6925 }
6926 } else if (s == 207.*207.) {
6927 double AFB_noBox, sigma = 0.0;
6928 if (!flagLEP2[ISR])
6929 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6930 else {
6931 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm205, &(*this), _1));
6932 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6933 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6934 }
6935 double numerator = average; // interval
6936
6937
6938 sigma = LEP2sigmaCharm(s);
6939
6940 AFB_noBox = numerator/sigma;
6941 }
6942 SMresult_cache = AFB_noBox;
6943
6944 if (flagLEP2[WeakBox]) {
6945 // numerator
6946 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm207, &(*this), _1));
6947 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6948 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6949 }
6950 double sigma_box_F = average; // interval
6951 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm207, &(*this), _1));
6952 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6953 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6954 }
6955 double sigma_box_B = average; // interval
6956
6957 // denominator
6958 if (!flagLEP2[ISR]) {
6959
6960 sigma = LEP2sigmaCharm(s);
6961 }
6962
6963 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6964 }
6965 } else {
6966 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2AFBcharm!");
6967 }
6968
6969 double AFBcharm = SMresult_cache;
6970
6971 gsl_set_error_handler(old_handler);
6972 bSigmaForAFB = false;
6973 return AFBcharm;
6974
6975}
An observable class for the forward-backward asymmetry in at the pole.
Definition: AFBcharm.h:32
virtual const double LEP2sigmaCharm(const double s) const
const double getIntegrand_AFBnumeratorWithISR_charm133(double x) const
const double getIntegrand_AFBnumeratorWithISR_charm183(double x) const
const double getIntegrand_AFBnumeratorWithISR_charm205(double x) const
const double getIntegrand_AFBnumeratorWithISR_charm200(double x) const
const double getIntegrand_AFBnumeratorWithISR_charm202(double x) const
const double getIntegrand_dsigmaBox_charm167(double x) const
const double getIntegrand_dsigmaBox_charm205(double x) const
const double getIntegrand_dsigmaBox_charm183(double x) const
const double getIntegrand_AFBnumeratorWithISR_charm189(double x) const
const double getIntegrand_dsigmaBox_charm196(double x) const
const double getIntegrand_AFBnumeratorWithISR_charm196(double x) const
const double getIntegrand_dsigmaBox_charm133(double x) const
const double getIntegrand_dsigmaBox_charm192(double x) const
const double getIntegrand_dsigmaBox_charm189(double x) const
const double getIntegrand_dsigmaBox_charm207(double x) const
const double getIntegrand_AFBnumeratorWithISR_charm167(double x) const
const double getIntegrand_dsigmaBox_charm200(double x) const
const double getIntegrand_dsigmaBox_charm202(double x) const
const double getIntegrand_AFBnumeratorWithISR_charm192(double x) const

◆ LEP2AFBe()

const double StandardModel::LEP2AFBe ( const double  s) const
virtual

Reimplemented in NPbase.

Definition at line 6977 of file StandardModel/src/StandardModel.cpp.

6978{
6979 return 0.;
6980}

◆ LEP2AFBmu()

const double StandardModel::LEP2AFBmu ( const double  s) const
virtual

Reimplemented in NPbase, and NPSTUVWXY.

Definition at line 6982 of file StandardModel/src/StandardModel.cpp.

6983{
6984
6985 bSigmaForAFB = true;
6986 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
6987 double relerr = 1.e-7;
6988 double abserr = 1.e-17;
6989
6990 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
6992
6993 /* SM contribution with the approximate formula */
6995
6996 } else {
6997
6998 if(s == 130.*130.){
6999 double AFB_noBox, sigma = 0.0;
7000 if (!flagLEP2[ISR])
7001 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7002 else {
7003 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu130, &(*this), _1));
7004 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7005 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7006 }
7007 double numerator = average; // interval
7008
7009
7010 sigma = LEP2sigmaMu(s);
7011
7012 AFB_noBox = numerator/sigma;
7013 }
7014 SMresult_cache = AFB_noBox;
7015
7016 if (flagLEP2[WeakBox]) {
7017 // numerator
7018 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu130, &(*this), _1));
7019 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7020 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7021 }
7022 double sigma_box_F = average; // interval
7023 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu130, &(*this), _1));
7024 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7025 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7026 }
7027 double sigma_box_B = average; // interval
7028
7029 // denominator
7030 if (!flagLEP2[ISR]) {
7031
7032 sigma = LEP2sigmaMu(s);
7033 }
7034
7035 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7036 }
7037 } else if (s == 136.*136.){
7038 double AFB_noBox, sigma = 0.0;
7039 if (!flagLEP2[ISR])
7040 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7041 else {
7042 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu136, &(*this), _1));
7043 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7044 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7045 }
7046 double numerator = average; // interval
7047
7048
7049 sigma = LEP2sigmaMu(s);
7050
7051 AFB_noBox = numerator/sigma;
7052 }
7053 SMresult_cache = AFB_noBox;
7054
7055 if (flagLEP2[WeakBox]) {
7056 // numerator
7057 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu136, &(*this), _1));
7058 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7059 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7060 }
7061 double sigma_box_F = average; // interval
7062 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu136, &(*this), _1));
7063 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7064 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7065 }
7066 double sigma_box_B = average; // interval
7067
7068 // denominator
7069 if (!flagLEP2[ISR]) {
7070
7071 sigma = LEP2sigmaMu(s);
7072 }
7073
7074 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7075 }
7076 } else if (s == 161.*161.){
7077 double AFB_noBox, sigma = 0.0;
7078 if (!flagLEP2[ISR])
7079 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7080 else {
7081 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu161, &(*this), _1));
7082 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7083 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7084 }
7085 double numerator = average; // interval
7086
7087
7088 sigma = LEP2sigmaMu(s);
7089
7090 AFB_noBox = numerator/sigma;
7091 }
7092 SMresult_cache = AFB_noBox;
7093
7094 if (flagLEP2[WeakBox]) {
7095 // numerator
7096 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu161, &(*this), _1));
7097 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7098 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7099 }
7100 double sigma_box_F = average; // interval
7101 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu161, &(*this), _1));
7102 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7103 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7104 }
7105 double sigma_box_B = average; // interval
7106
7107 // denominator
7108 if (!flagLEP2[ISR]) {
7109
7110 sigma = LEP2sigmaMu(s);
7111 }
7112
7113 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7114 }
7115 } else if (s == 172.*172.){
7116 double AFB_noBox, sigma = 0.0;
7117 if (!flagLEP2[ISR])
7118 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7119 else {
7120 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu172, &(*this), _1));
7121 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7122 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7123 }
7124 double numerator = average; // interval
7125
7126
7127 sigma = LEP2sigmaMu(s);
7128
7129 AFB_noBox = numerator/sigma;
7130 }
7131 SMresult_cache = AFB_noBox;
7132
7133 if (flagLEP2[WeakBox]) {
7134 // numerator
7135 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu172, &(*this), _1));
7136 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7137 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7138 }
7139 double sigma_box_F = average; // interval
7140 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu172, &(*this), _1));
7141 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7142 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7143 }
7144 double sigma_box_B = average; // interval
7145
7146 // denominator
7147 if (!flagLEP2[ISR]) {
7148
7149 sigma = LEP2sigmaMu(s);
7150 }
7151
7152 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7153 }
7154 } else if (s == 183.*183.) {
7155 double AFB_noBox, sigma = 0.0;
7156 if (!flagLEP2[ISR])
7157 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7158 else {
7159 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu183, &(*this), _1));
7160 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7161 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7162 }
7163 double numerator = average; // interval
7164
7165
7166 sigma = LEP2sigmaMu(s);
7167
7168 AFB_noBox = numerator/sigma;
7169 }
7170 SMresult_cache = AFB_noBox;
7171
7172 if (flagLEP2[WeakBox]) {
7173 // numerator
7174 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu183, &(*this), _1));
7175 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7176 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7177 }
7178 double sigma_box_F = average; // interval
7179 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu183, &(*this), _1));
7180 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7181 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7182 }
7183 double sigma_box_B = average; // interval
7184
7185 // denominator
7186 if (!flagLEP2[ISR]) {
7187
7188 sigma = LEP2sigmaMu(s);
7189 }
7190
7191 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7192 }
7193 } else if (s == 189.*189.) {
7194 double AFB_noBox, sigma = 0.0;
7195 if (!flagLEP2[ISR])
7196 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7197 else {
7198 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu189, &(*this), _1));
7199 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7200 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7201 }
7202 double numerator = average; // interval
7203
7204
7205 sigma = LEP2sigmaMu(s);
7206
7207 AFB_noBox = numerator/sigma;
7208 }
7209 SMresult_cache = AFB_noBox;
7210
7211 if (flagLEP2[WeakBox]) {
7212 // numerator
7213 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu189, &(*this), _1));
7214 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7215 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7216 }
7217 double sigma_box_F = average; // interval
7218 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu189, &(*this), _1));
7219 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7220 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7221 }
7222 double sigma_box_B = average; // interval
7223
7224 // denominator
7225 if (!flagLEP2[ISR]) {
7226
7227 sigma = LEP2sigmaMu(s);
7228 }
7229
7230 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7231 }
7232 } else if (s == 192.*192.) {
7233 double AFB_noBox, sigma = 0.0;
7234 if (!flagLEP2[ISR])
7235 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7236 else {
7237 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu192, &(*this), _1));
7238 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7239 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7240 }
7241 double numerator = average; // interval
7242
7243
7244 sigma = LEP2sigmaMu(s);
7245
7246 AFB_noBox = numerator/sigma;
7247 }
7248 SMresult_cache = AFB_noBox;
7249
7250 if (flagLEP2[WeakBox]) {
7251 // numerator
7252 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu192, &(*this), _1));
7253 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7254 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7255 }
7256 double sigma_box_F = average; // interval
7257 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu192, &(*this), _1));
7258 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7259 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7260 }
7261 double sigma_box_B = average; // interval
7262
7263 // denominator
7264 if (!flagLEP2[ISR]) {
7265
7266 sigma = LEP2sigmaMu(s);
7267 }
7268
7269 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7270 }
7271 } else if (s == 196.*196.) {
7272 double AFB_noBox, sigma = 0.0;
7273 if (!flagLEP2[ISR])
7274 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7275 else {
7276 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu196, &(*this), _1));
7277 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7278 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7279 }
7280 double numerator = average; // interval
7281
7282
7283 sigma = LEP2sigmaMu(s);
7284
7285 AFB_noBox = numerator/sigma;
7286 }
7287 SMresult_cache = AFB_noBox;
7288
7289 if (flagLEP2[WeakBox]) {
7290 // numerator
7291 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu196, &(*this), _1));
7292 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7293 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7294 }
7295 double sigma_box_F = average; // interval
7296 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu196, &(*this), _1));
7297 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7298 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7299 }
7300 double sigma_box_B = average; // interval
7301
7302 // denominator
7303 if (!flagLEP2[ISR]) {
7304
7305 sigma = LEP2sigmaMu(s);
7306 }
7307
7308 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7309 }
7310 } else if (s == 200.*200.) {
7311 double AFB_noBox, sigma = 0.0;
7312 if (!flagLEP2[ISR])
7313 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7314 else {
7315 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu200, &(*this), _1));
7316 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7317 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7318 }
7319 double numerator = average; // interval
7320
7321
7322 sigma = LEP2sigmaMu(s);
7323
7324 AFB_noBox = numerator/sigma;
7325 }
7326 SMresult_cache = AFB_noBox;
7327
7328 if (flagLEP2[WeakBox]) {
7329 // numerator
7330 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu200, &(*this), _1));
7331 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7332 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7333 }
7334 double sigma_box_F = average; // interval
7335 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu200, &(*this), _1));
7336 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7337 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7338 }
7339 double sigma_box_B = average; // interval
7340
7341 // denominator
7342 if (!flagLEP2[ISR]) {
7343
7344 sigma = LEP2sigmaMu(s);
7345 }
7346
7347 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7348 }
7349 } else if (s == 202.*202.) {
7350 double AFB_noBox, sigma = 0.0;
7351 if (!flagLEP2[ISR])
7352 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7353 else {
7354 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu202, &(*this), _1));
7355 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7356 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7357 }
7358 double numerator = average; // interval
7359
7360
7361 sigma = LEP2sigmaMu(s);
7362
7363 AFB_noBox = numerator/sigma;
7364 }
7365 SMresult_cache = AFB_noBox;
7366
7367 if (flagLEP2[WeakBox]) {
7368 // numerator
7369 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu202, &(*this), _1));
7370 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7371 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7372 }
7373 double sigma_box_F = average; // interval
7374 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu202, &(*this), _1));
7375 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7376 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7377 }
7378 double sigma_box_B = average; // interval
7379
7380 // denominator
7381 if (!flagLEP2[ISR]) {
7382
7383 sigma = LEP2sigmaMu(s);
7384 }
7385
7386 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7387 }
7388 } else if (s == 205.*205.) {
7389 double AFB_noBox, sigma = 0.0;
7390 if (!flagLEP2[ISR])
7391 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7392 else {
7393 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu205, &(*this), _1));
7394 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7395 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7396 }
7397 double numerator = average; // interval
7398
7399
7400 sigma = LEP2sigmaMu(s);
7401
7402 AFB_noBox = numerator/sigma;
7403 }
7404 SMresult_cache = AFB_noBox;
7405
7406 if (flagLEP2[WeakBox]) {
7407 // numerator
7408 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu205, &(*this), _1));
7409 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7410 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7411 }
7412 double sigma_box_F = average; // interval
7413 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu205, &(*this), _1));
7414 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7415 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7416 }
7417 double sigma_box_B = average; // interval
7418
7419 // denominator
7420 if (!flagLEP2[ISR]) {
7421
7422 sigma = LEP2sigmaMu(s);
7423 }
7424
7425 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7426 }
7427 } else if (s == 207.*207.) {
7428 double AFB_noBox, sigma = 0.0;
7429 if (!flagLEP2[ISR])
7430 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7431 else {
7432 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu207, &(*this), _1));
7433 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7434 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7435 }
7436 double numerator = average; // interval
7437
7438
7439 sigma = LEP2sigmaMu(s);
7440
7441 AFB_noBox = numerator/sigma;
7442 }
7443 SMresult_cache = AFB_noBox;
7444
7445 if (flagLEP2[WeakBox]) {
7446 // numerator
7447 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu207, &(*this), _1));
7448 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7449 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7450 }
7451 double sigma_box_F = average; // interval
7452 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu207, &(*this), _1));
7453 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7454 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7455 }
7456 double sigma_box_B = average; // interval
7457
7458 // denominator
7459 if (!flagLEP2[ISR]) {
7460
7461 sigma = LEP2sigmaMu(s);
7462 }
7463
7464 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7465 }
7466 } else {
7467 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::AFBmu!");
7468 }
7469
7470 double AFBmu = SMresult_cache;
7471
7472 gsl_set_error_handler(old_handler);
7473 bSigmaForAFB = false;
7474 return AFBmu;
7475 }
7476}
double LEP2AFBmuApprox(const double s) const
The forward-backward asymmetry at LEP2.
const double getIntegrand_dsigmaBox_mu200(double x) const
const double getIntegrand_AFBnumeratorWithISR_mu192(double x) const
const double getIntegrand_dsigmaBox_mu207(double x) const
const double getIntegrand_AFBnumeratorWithISR_mu207(double x) const
const double getIntegrand_dsigmaBox_mu136(double x) const
const double getIntegrand_AFBnumeratorWithISR_mu196(double x) const
const double getIntegrand_dsigmaBox_mu189(double x) const
const double getIntegrand_AFBnumeratorWithISR_mu136(double x) const
const double getIntegrand_AFBnumeratorWithISR_mu130(double x) const
const double getIntegrand_AFBnumeratorWithISR_mu172(double x) const
const double getIntegrand_AFBnumeratorWithISR_mu202(double x) const
const double getIntegrand_dsigmaBox_mu161(double x) const
const double getIntegrand_dsigmaBox_mu183(double x) const
const double getIntegrand_dsigmaBox_mu172(double x) const
const double getIntegrand_dsigmaBox_mu192(double x) const
const double getIntegrand_dsigmaBox_mu196(double x) const
const double getIntegrand_AFBnumeratorWithISR_mu205(double x) const
const double getIntegrand_dsigmaBox_mu202(double x) const
const double getIntegrand_AFBnumeratorWithISR_mu189(double x) const
virtual const double LEP2sigmaMu(const double s) const
const double getIntegrand_dsigmaBox_mu205(double x) const
const double getIntegrand_AFBnumeratorWithISR_mu200(double x) const
const double AFB_NoISR_l(const QCD::lepton l_flavor, const double s) const
const double getIntegrand_AFBnumeratorWithISR_mu161(double x) const
const double getIntegrand_dsigmaBox_mu130(double x) const
const double getIntegrand_AFBnumeratorWithISR_mu183(double x) const

◆ LEP2AFBtau()

const double StandardModel::LEP2AFBtau ( const double  s) const
virtual

Reimplemented in NPbase, and NPSTUVWXY.

Definition at line 7479 of file StandardModel/src/StandardModel.cpp.

7480{
7481
7482 bSigmaForAFB = true;
7483 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
7484 double relerr = 1.e-7;
7485 double abserr = 1.e-17;
7486
7487 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
7489
7490 /* SM contribution with the approximate formula */
7492
7493 } else {
7494
7495 if(s == 130.*130.){
7496 double AFB_noBox, sigma = 0.0;
7497 if (!flagLEP2[ISR])
7498 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7499 else {
7500 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau130, &(*this), _1));
7501 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7502 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7503 }
7504 double numerator = average; // interval
7505
7506
7507 sigma = LEP2sigmaTau(s);
7508
7509 AFB_noBox = numerator/sigma;
7510 }
7511 SMresult_cache = AFB_noBox;
7512
7513 if (flagLEP2[WeakBox]) {
7514 // numerator
7515 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau130, &(*this), _1));
7516 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7517 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7518 }
7519 double sigma_box_F = average; // interval
7520 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau130, &(*this), _1));
7521 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7522 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7523 }
7524 double sigma_box_B = average; // interval
7525
7526 // denominator
7527 if (!flagLEP2[ISR]) {
7528
7529 sigma = LEP2sigmaTau(s);
7530 }
7531
7532 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7533 }
7534 } else if (s == 136.*136.){
7535 double AFB_noBox, sigma = 0.0;
7536 if (!flagLEP2[ISR])
7537 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7538 else {
7539 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau136, &(*this), _1));
7540 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7541 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7542 }
7543 double numerator = average; // interval
7544
7545
7546 sigma = LEP2sigmaTau(s);
7547
7548 AFB_noBox = numerator/sigma;
7549 }
7550 SMresult_cache = AFB_noBox;
7551
7552 if (flagLEP2[WeakBox]) {
7553 // numerator
7554 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau136, &(*this), _1));
7555 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7556 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7557 }
7558 double sigma_box_F = average; // interval
7559 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau136, &(*this), _1));
7560 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7561 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7562 }
7563 double sigma_box_B = average; // interval
7564
7565 // denominator
7566 if (!flagLEP2[ISR]) {
7567
7568 sigma = LEP2sigmaTau(s);
7569 }
7570
7571 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7572 }
7573 } else if (s == 161.*161.){
7574 double AFB_noBox, sigma = 0.0;
7575 if (!flagLEP2[ISR])
7576 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7577 else {
7578 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau161, &(*this), _1));
7579 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7580 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7581 }
7582 double numerator = average; // interval
7583
7584
7585 sigma = LEP2sigmaTau(s);
7586
7587 AFB_noBox = numerator/sigma;
7588 }
7589 SMresult_cache = AFB_noBox;
7590
7591 if (flagLEP2[WeakBox]) {
7592 // numerator
7593 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau161, &(*this), _1));
7594 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7595 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7596 }
7597 double sigma_box_F = average; // interval
7598 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau161, &(*this), _1));
7599 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7600 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7601 }
7602 double sigma_box_B = average; // interval
7603
7604 // denominator
7605 if (!flagLEP2[ISR]) {
7606
7607 sigma = LEP2sigmaTau(s);
7608 }
7609
7610 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7611 }
7612 } else if (s == 172.*172.){
7613 double AFB_noBox, sigma = 0.0;
7614 if (!flagLEP2[ISR])
7615 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7616 else {
7617 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau172, &(*this), _1));
7618 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7619 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7620 }
7621 double numerator = average; // interval
7622
7623
7624 sigma = LEP2sigmaTau(s);
7625
7626 AFB_noBox = numerator/sigma;
7627 }
7628 SMresult_cache = AFB_noBox;
7629
7630 if (flagLEP2[WeakBox]) {
7631 // numerator
7632 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau172, &(*this), _1));
7633 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7634 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7635 }
7636 double sigma_box_F = average; // interval
7637 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau172, &(*this), _1));
7638 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7639 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7640 }
7641 double sigma_box_B = average; // interval
7642
7643 // denominator
7644 if (!flagLEP2[ISR]) {
7645
7646 sigma = LEP2sigmaTau(s);
7647 }
7648
7649 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7650 }
7651 } else if (s == 183.*183.) {
7652 double AFB_noBox, sigma = 0.0;
7653 if (!flagLEP2[ISR])
7654 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7655 else {
7656 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau183, &(*this), _1));
7657 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7658 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7659 }
7660 double numerator = average; // interval
7661
7662
7663 sigma = LEP2sigmaTau(s);
7664
7665 AFB_noBox = numerator/sigma;
7666 }
7667 SMresult_cache = AFB_noBox;
7668
7669 if (flagLEP2[WeakBox]) {
7670 // numerator
7671 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau183, &(*this), _1));
7672 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7673 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7674 }
7675 double sigma_box_F = average; // interval
7676 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau183, &(*this), _1));
7677 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7678 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7679 }
7680 double sigma_box_B = average; // interval
7681
7682 // denominator
7683 if (!flagLEP2[ISR]) {
7684
7685 sigma = LEP2sigmaTau(s);
7686 }
7687
7688 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7689 }
7690 } else if (s == 189.*189.) {
7691 double AFB_noBox, sigma = 0.0;
7692 if (!flagLEP2[ISR])
7693 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7694 else {
7695 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau189, &(*this), _1));
7696 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7697 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7698 }
7699 double numerator = average; // interval
7700
7701
7702 sigma = LEP2sigmaTau(s);
7703
7704 AFB_noBox = numerator/sigma;
7705 }
7706 SMresult_cache = AFB_noBox;
7707
7708 if (flagLEP2[WeakBox]) {
7709 // numerator
7710 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau189, &(*this), _1));
7711 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7712 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7713 }
7714 double sigma_box_F = average; // interval
7715 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau189, &(*this), _1));
7716 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7717 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7718 }
7719 double sigma_box_B = average; // interval
7720
7721 // denominator
7722 if (!flagLEP2[ISR]) {
7723
7724 sigma = LEP2sigmaTau(s);
7725 }
7726
7727 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7728 }
7729 } else if (s == 192.*192.) {
7730 double AFB_noBox, sigma = 0.0;
7731 if (!flagLEP2[ISR])
7732 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7733 else {
7734 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau192, &(*this), _1));
7735 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7736 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7737 }
7738 double numerator = average; // interval
7739
7740
7741 sigma = LEP2sigmaTau(s);
7742
7743 AFB_noBox = numerator/sigma;
7744 }
7745 SMresult_cache = AFB_noBox;
7746
7747 if (flagLEP2[WeakBox]) {
7748 // numerator
7749 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau192, &(*this), _1));
7750 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7751 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7752 }
7753 double sigma_box_F = average; // interval
7754 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau192, &(*this), _1));
7755 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7756 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7757 }
7758 double sigma_box_B = average; // interval
7759
7760 // denominator
7761 if (!flagLEP2[ISR]) {
7762
7763 sigma = LEP2sigmaTau(s);
7764 }
7765
7766 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7767 }
7768 } else if (s == 196.*196.) {
7769 double AFB_noBox, sigma = 0.0;
7770 if (!flagLEP2[ISR])
7771 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7772 else {
7773 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau196, &(*this), _1));
7774 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7775 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7776 }
7777 double numerator = average; // interval
7778
7779
7780 sigma = LEP2sigmaTau(s);
7781
7782 AFB_noBox = numerator/sigma;
7783 }
7784 SMresult_cache = AFB_noBox;
7785
7786 if (flagLEP2[WeakBox]) {
7787 // numerator
7788 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau196, &(*this), _1));
7789 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7790 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7791 }
7792 double sigma_box_F = average; // interval
7793 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau196, &(*this), _1));
7794 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7795 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7796 }
7797 double sigma_box_B = average; // interval
7798
7799 // denominator
7800 if (!flagLEP2[ISR]) {
7801
7802 sigma = LEP2sigmaTau(s);
7803 }
7804
7805 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7806 }
7807 } else if (s == 200.*200.) {
7808 double AFB_noBox, sigma = 0.0;
7809 if (!flagLEP2[ISR])
7810 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7811 else {
7812 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau200, &(*this), _1));
7813 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7814 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7815 }
7816 double numerator = average; // interval
7817
7818
7819 sigma = LEP2sigmaTau(s);
7820
7821 AFB_noBox = numerator/sigma;
7822 }
7823 SMresult_cache = AFB_noBox;
7824
7825 if (flagLEP2[WeakBox]) {
7826 // numerator
7827 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau200, &(*this), _1));
7828 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7829 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7830 }
7831 double sigma_box_F = average; // interval
7832 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau200, &(*this), _1));
7833 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7834 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7835 }
7836 double sigma_box_B = average; // interval
7837
7838 // denominator
7839 if (!flagLEP2[ISR]) {
7840
7841 sigma = LEP2sigmaTau(s);
7842 }
7843
7844 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7845 }
7846 } else if (s == 202.*202.) {
7847 double AFB_noBox, sigma = 0.0;
7848 if (!flagLEP2[ISR])
7849 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7850 else {
7851 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau202, &(*this), _1));
7852 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7853 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7854 }
7855 double numerator = average; // interval
7856
7857
7858 sigma = LEP2sigmaTau(s);
7859
7860 AFB_noBox = numerator/sigma;
7861 }
7862 SMresult_cache = AFB_noBox;
7863
7864 if (flagLEP2[WeakBox]) {
7865 // numerator
7866 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau202, &(*this), _1));
7867 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7868 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7869 }
7870 double sigma_box_F = average; // interval
7871 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau202, &(*this), _1));
7872 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7873 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7874 }
7875 double sigma_box_B = average; // interval
7876
7877 // denominator
7878 if (!flagLEP2[ISR]) {
7879
7880 sigma = LEP2sigmaTau(s);
7881 }
7882
7883 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7884 }
7885 } else if (s == 205.*205.) {
7886 double AFB_noBox, sigma = 0.0;
7887 if (!flagLEP2[ISR])
7888 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7889 else {
7890 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau205, &(*this), _1));
7891 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7892 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7893 }
7894 double numerator = average; // interval
7895
7896
7897 sigma = LEP2sigmaTau(s);
7898
7899 AFB_noBox = numerator/sigma;
7900 }
7901 SMresult_cache = AFB_noBox;
7902
7903 if (flagLEP2[WeakBox]) {
7904 // numerator
7905 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau205, &(*this), _1));
7906 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7907 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7908 }
7909 double sigma_box_F = average; // interval
7910 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau205, &(*this), _1));
7911 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7912 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7913 }
7914 double sigma_box_B = average; // interval
7915
7916 // denominator
7917 if (!flagLEP2[ISR]) {
7918
7919 sigma = LEP2sigmaTau(s);
7920 }
7921
7922 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7923 }
7924 } else if (s == 207.*207.) {
7925 double AFB_noBox, sigma = 0.0;
7926 if (!flagLEP2[ISR])
7927 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7928 else {
7929 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau207, &(*this), _1));
7930 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7931 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7932 }
7933 double numerator = average; // interval
7934
7935
7936 sigma = LEP2sigmaTau(s);
7937
7938 AFB_noBox = numerator/sigma;
7939 }
7940 SMresult_cache = AFB_noBox;
7941
7942 if (flagLEP2[WeakBox]) {
7943 // numerator
7944 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau207, &(*this), _1));
7945 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7946 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7947 }
7948 double sigma_box_F = average; // interval
7949 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau207, &(*this), _1));
7950 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7951 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7952 }
7953 double sigma_box_B = average; // interval
7954
7955 // denominator
7956 if (!flagLEP2[ISR]) {
7957
7958 sigma = LEP2sigmaTau(s);
7959 }
7960
7961 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7962 }
7963 } else {
7964 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2AFBtau!");
7965 }
7966
7967 double AFBtau = SMresult_cache;
7968
7969 gsl_set_error_handler(old_handler);
7970 bSigmaForAFB = false;
7971 return AFBtau;
7972 }
7973}
An observable class for the forward-backward asymmetry in at the pole.
Definition: AFBlepton.h:160
double LEP2AFBtauApprox(const double s) const
The forward-backward asymmetry at LEP2.
const double getIntegrand_AFBnumeratorWithISR_tau130(double x) const
const double getIntegrand_AFBnumeratorWithISR_tau200(double x) const
const double getIntegrand_dsigmaBox_tau136(double x) const
virtual const double LEP2sigmaTau(const double s) const
const double getIntegrand_AFBnumeratorWithISR_tau172(double x) const
const double getIntegrand_AFBnumeratorWithISR_tau192(double x) const
const double getIntegrand_AFBnumeratorWithISR_tau196(double x) const
const double getIntegrand_dsigmaBox_tau183(double x) const
const double getIntegrand_dsigmaBox_tau196(double x) const
const double getIntegrand_dsigmaBox_tau192(double x) const
const double getIntegrand_AFBnumeratorWithISR_tau136(double x) const
const double getIntegrand_dsigmaBox_tau189(double x) const
const double getIntegrand_AFBnumeratorWithISR_tau183(double x) const
const double getIntegrand_dsigmaBox_tau202(double x) const
const double getIntegrand_dsigmaBox_tau172(double x) const
const double getIntegrand_dsigmaBox_tau200(double x) const
const double getIntegrand_AFBnumeratorWithISR_tau202(double x) const
const double getIntegrand_dsigmaBox_tau161(double x) const
const double getIntegrand_AFBnumeratorWithISR_tau207(double x) const
const double getIntegrand_AFBnumeratorWithISR_tau205(double x) const
const double getIntegrand_dsigmaBox_tau207(double x) const
const double getIntegrand_AFBnumeratorWithISR_tau189(double x) const
const double getIntegrand_AFBnumeratorWithISR_tau161(double x) const
const double getIntegrand_dsigmaBox_tau130(double x) const
const double getIntegrand_dsigmaBox_tau205(double x) const

◆ LEP2dsigmadcosBinE()

const double StandardModel::LEP2dsigmadcosBinE ( const double  s,
const double  cos,
const double  cosmin,
const double  cosmax 
) const
virtual

Reimplemented in NPbase.

Definition at line 9645 of file StandardModel/src/StandardModel.cpp.

9646{
9647 return LEP2dsigmadcosE(s, cos);
9648}
virtual const double LEP2dsigmadcosE(const double s, const double cos) const

◆ LEP2dsigmadcosBinMu()

const double StandardModel::LEP2dsigmadcosBinMu ( const double  s,
const double  cos,
const double  cosmin,
const double  cosmax 
) const
virtual

Reimplemented in NPbase.

Definition at line 9650 of file StandardModel/src/StandardModel.cpp.

9651{
9652 return LEP2dsigmadcosMu(s, cos);
9653}
virtual const double LEP2dsigmadcosMu(const double s, const double cos) const

◆ LEP2dsigmadcosBinTau()

const double StandardModel::LEP2dsigmadcosBinTau ( const double  s,
const double  cos,
const double  cosmin,
const double  cosmax 
) const
virtual

Reimplemented in NPbase.

Definition at line 9655 of file StandardModel/src/StandardModel.cpp.

9656{
9657 return LEP2dsigmadcosTau(s, cos);
9658}
virtual const double LEP2dsigmadcosTau(const double s, const double cos) const

◆ LEP2dsigmadcosE()

const double StandardModel::LEP2dsigmadcosE ( const double  s,
const double  cos 
) const
virtual

Reimplemented in NPbase.

Definition at line 9603 of file StandardModel/src/StandardModel.cpp.

9604{
9605 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
9607
9608 /* SM contribution with the approximate formula */
9610
9611 } else {
9612 throw std::runtime_error("ERROR: StandardModel::LEP2dsigmadcosE only implemented via semi-analytical approx");
9613 }
9614}
double LEP2dsigmadcosEApprox(const double s, const double cos) const
The differential cross section at LEP2.

◆ LEP2dsigmadcosMu()

const double StandardModel::LEP2dsigmadcosMu ( const double  s,
const double  cos 
) const
virtual

Reimplemented in NPbase.

Definition at line 9616 of file StandardModel/src/StandardModel.cpp.

9617{
9618 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
9620
9621 /* SM contribution with the approximate formula */
9623
9624 } else {
9625 throw std::runtime_error("ERROR: StandardModel::LEP2dsigmadcosMu only implemented via semi-analytical approx");
9626 }
9627}
double LEP2dsigmadcosMuApprox(const double s, const double cos) const
The differential cross section at LEP2.

◆ LEP2dsigmadcosTau()

const double StandardModel::LEP2dsigmadcosTau ( const double  s,
const double  cos 
) const
virtual

Reimplemented in NPbase.

Definition at line 9629 of file StandardModel/src/StandardModel.cpp.

9630{
9631 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
9633
9634 /* SM contribution with the approximate formula */
9636
9637 } else {
9638 throw std::runtime_error("ERROR: StandardModel::LEP2dsigmadcosTau only implemented via semi-analytical approx");
9639 }
9640}
double LEP2dsigmadcosTauApprox(const double s, const double cos) const
The differential cross section at LEP2.

◆ LEP2Rbottom()

const double StandardModel::LEP2Rbottom ( const double  s) const
virtual

Reimplemented in NPbase, and NPSTUVWXY.

Definition at line 7976 of file StandardModel/src/StandardModel.cpp.

7977{
7978
7979 double sigma_b = LEP2sigmaBottom(s);
7980 double sigma_had = LEP2sigmaHadron(s);
7981 SMresult_cache = sigma_b / sigma_had;
7982 double R_bottom = SMresult_cache;
7983
7984 return R_bottom;
7985}
virtual const double LEP2sigmaHadron(const double s) const

◆ LEP2Rcharm()

const double StandardModel::LEP2Rcharm ( const double  s) const
virtual

Reimplemented in NPbase, and NPSTUVWXY.

Definition at line 7988 of file StandardModel/src/StandardModel.cpp.

7989{
7990
7991 double sigma_c = LEP2sigmaCharm(s);
7992 double sigma_had = LEP2sigmaHadron(s);
7993 SMresult_cache = sigma_c / sigma_had;
7994 double R_charm = SMresult_cache;
7995
7996 return R_charm;
7997}

◆ LEP2sigmaBottom()

const double StandardModel::LEP2sigmaBottom ( const double  s) const
virtual

Reimplemented in NPbase, and NPSTUVWXY.

Definition at line 4813 of file StandardModel/src/StandardModel.cpp.

4814{
4815 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
4816 double relerr = 1.e-8;
4817 double abserr = 1.e-20;
4818
4819 if(s == 133.*133.){
4820
4821 if (!flagLEP2[ISR]){
4823 } else {
4824 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom133, &(*this), _1));
4825 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4826 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4827 }
4829 }
4830
4831 if (flagLEP2[WeakBox]) {
4832 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom133, &(*this), _1));
4833 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4834 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4835 }
4836 double sigma_box = average;
4837 SMresult_cache += sigma_box;
4838 }
4839 } else if (s == 167.*167.){
4840 if (!flagLEP2[ISR])
4842 else {
4843 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom167, &(*this), _1));
4844 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4845 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4846 }
4848 }
4849
4850 if (flagLEP2[WeakBox]) {
4851 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom167, &(*this), _1));
4852 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4853 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4854 }
4855 double sigma_box = average;
4856 SMresult_cache += sigma_box;
4857 }
4858 } else if (s == 183.*183.) {
4859 if (!flagLEP2[ISR])
4861 else {
4862 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom183, &(*this), _1));
4863 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4864 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4865 }
4867 }
4868
4869 if (flagLEP2[WeakBox]) {
4870 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom183, &(*this), _1));
4871 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4872 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4873 }
4874 double sigma_box = average;
4875 SMresult_cache += sigma_box;
4876 }
4877 } else if (s == 189.*189.) {
4878 if (!flagLEP2[ISR])
4880 else {
4881 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom189, &(*this), _1));
4882 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4883 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4884 }
4886 }
4887
4888 if (flagLEP2[WeakBox]) {
4889 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom189, &(*this), _1));
4890 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4891 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4892 }
4893 double sigma_box = average;
4894 SMresult_cache += sigma_box;
4895 }
4896 } else if (s == 192.*192.) {
4897 if (!flagLEP2[ISR])
4899 else {
4900 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom192, &(*this), _1));
4901 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4902 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4903 }
4905 }
4906
4907 if (flagLEP2[WeakBox]) {
4908 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom192, &(*this), _1));
4909 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4910 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4911 }
4912 double sigma_box = average;
4913 SMresult_cache += sigma_box;
4914 }
4915 } else if (s == 196.*196.) {
4916 if (!flagLEP2[ISR])
4918 else {
4919 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom196, &(*this), _1));
4920 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4921 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4922 }
4924 }
4925
4926 if (flagLEP2[WeakBox]) {
4927 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom196, &(*this), _1));
4928 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4929 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4930 }
4931 double sigma_box = average;
4932 SMresult_cache += sigma_box;
4933 }
4934 } else if (s == 200.*200.) {
4935 if (!flagLEP2[ISR])
4937 else {
4938 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom200, &(*this), _1));
4939 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4940 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4941 }
4943 }
4944
4945 if (flagLEP2[WeakBox]) {
4946 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom200, &(*this), _1));
4947 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4948 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4949 }
4950 double sigma_box = average;
4951 SMresult_cache += sigma_box;
4952 }
4953 } else if (s == 202.*202.) {
4954 if (!flagLEP2[ISR])
4956 else {
4957 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom202, &(*this), _1));
4958 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4959 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4960 }
4962 }
4963
4964 if (flagLEP2[WeakBox]) {
4965 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom202, &(*this), _1));
4966 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4967 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4968 }
4969 double sigma_box = average;
4970 SMresult_cache += sigma_box;
4971 }
4972 } else if (s == 205.*205.) {
4973 if (!flagLEP2[ISR])
4975 else {
4976 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom205, &(*this), _1));
4977 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4978 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4979 }
4981 }
4982
4983 if (flagLEP2[WeakBox]) {
4984 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom205, &(*this), _1));
4985 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4986 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4987 }
4988 double sigma_box = average;
4989 SMresult_cache += sigma_box;
4990 }
4991 } else if (s == 207.*207.) {
4992 if (!flagLEP2[ISR])
4994 else {
4995 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom207, &(*this), _1));
4996 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4997 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4998 }
5000 }
5001
5002 if (flagLEP2[WeakBox]) {
5003 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom207, &(*this), _1));
5004 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5005 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5006 }
5007 double sigma_box = average;
5008 SMresult_cache += sigma_box;
5009 }
5010 } else {
5011 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2sigmaBottom!");
5012 }
5013
5014
5015 double sigma_mu = SMresult_cache;
5016
5017 gsl_set_error_handler(old_handler);
5018
5019 return sigma_mu;
5020
5021}
const double getIntegrand_sigmaWithISR_bottom200(double x) const
const double getIntegrand_sigmaWithISR_bottom207(double x) const
const double getIntegrand_sigmaWithISR_bottom192(double x) const
const double sigma_NoISR_q(const QCD::quark q_flavor, const double s) const
const double getIntegrand_sigmaWithISR_bottom196(double x) const
const double getIntegrand_sigmaWithISR_bottom205(double x) const
const double getIntegrand_sigmaWithISR_bottom133(double x) const
const double getIntegrand_sigmaWithISR_bottom202(double x) const
const double getIntegrand_sigmaWithISR_bottom167(double x) const
const double getIntegrand_sigmaWithISR_bottom183(double x) const
const double getIntegrand_sigmaWithISR_bottom189(double x) const

◆ LEP2sigmaCharm()

const double StandardModel::LEP2sigmaCharm ( const double  s) const
virtual

Reimplemented in NPbase, and NPSTUVWXY.

Definition at line 4602 of file StandardModel/src/StandardModel.cpp.

4603{
4604 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
4605 double relerr = 1.e-8;
4606 double abserr = 1.e-20;
4607
4608 if(s == 133.*133.){
4609
4610 if (!flagLEP2[ISR]){
4612 } else {
4613 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm133, &(*this), _1));
4614 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4615 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4616 }
4618 }
4619
4620 if (flagLEP2[WeakBox]) {
4621 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm133, &(*this), _1));
4622 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4623 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4624 }
4625 double sigma_box = average;
4626 SMresult_cache += sigma_box;
4627 }
4628 } else if (s == 167.*167.){
4629 if (!flagLEP2[ISR])
4631 else {
4632 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm167, &(*this), _1));
4633 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4634 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4635 }
4637 }
4638
4639 if (flagLEP2[WeakBox]) {
4640 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm167, &(*this), _1));
4641 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4642 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4643 }
4644 double sigma_box = average;
4645 SMresult_cache += sigma_box;
4646 }
4647 } else if (s == 183.*183.) {
4648 if (!flagLEP2[ISR])
4650 else {
4651 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm183, &(*this), _1));
4652 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4653 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4654 }
4656 }
4657
4658 if (flagLEP2[WeakBox]) {
4659 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm183, &(*this), _1));
4660 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4661 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4662 }
4663 double sigma_box = average;
4664 SMresult_cache += sigma_box;
4665 }
4666 } else if (s == 189.*189.) {
4667 if (!flagLEP2[ISR])
4669 else {
4670 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm189, &(*this), _1));
4671 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4672 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4673 }
4675 }
4676
4677 if (flagLEP2[WeakBox]) {
4678 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm189, &(*this), _1));
4679 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4680 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4681 }
4682 double sigma_box = average;
4683 SMresult_cache += sigma_box;
4684 }
4685 } else if (s == 192.*192.) {
4686 if (!flagLEP2[ISR])
4688 else {
4689 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm192, &(*this), _1));
4690 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4691 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4692 }
4694 }
4695
4696 if (flagLEP2[WeakBox]) {
4697 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm192, &(*this), _1));
4698 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4699 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4700 }
4701 double sigma_box = average;
4702 SMresult_cache += sigma_box;
4703 }
4704 } else if (s == 196.*196.) {
4705 if (!flagLEP2[ISR])
4707 else {
4708 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm196, &(*this), _1));
4709 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4710 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4711 }
4713 }
4714
4715 if (flagLEP2[WeakBox]) {
4716 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm196, &(*this), _1));
4717 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4718 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4719 }
4720 double sigma_box = average;
4721 SMresult_cache += sigma_box;
4722 }
4723 } else if (s == 200.*200.) {
4724 if (!flagLEP2[ISR])
4726 else {
4727 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm200, &(*this), _1));
4728 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4729 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4730 }
4732 }
4733
4734 if (flagLEP2[WeakBox]) {
4735 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm200, &(*this), _1));
4736 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4737 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4738 }
4739 double sigma_box = average;
4740 SMresult_cache += sigma_box;
4741 }
4742 } else if (s == 202.*202.) {
4743 if (!flagLEP2[ISR])
4745 else {
4746 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm202, &(*this), _1));
4747 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4748 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4749 }
4751 }
4752
4753 if (flagLEP2[WeakBox]) {
4754 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm202, &(*this), _1));
4755 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4756 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4757 }
4758 double sigma_box = average;
4759 SMresult_cache += sigma_box;
4760 }
4761 } else if (s == 205.*205.) {
4762 if (!flagLEP2[ISR])
4764 else {
4765 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm205, &(*this), _1));
4766 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4767 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4768 }
4770 }
4771
4772 if (flagLEP2[WeakBox]) {
4773 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm205, &(*this), _1));
4774 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4775 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4776 }
4777 double sigma_box = average;
4778 SMresult_cache += sigma_box;
4779 }
4780 } else if (s == 207.*207.) {
4781 if (!flagLEP2[ISR])
4783 else {
4784 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm207, &(*this), _1));
4785 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4786 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4787 }
4789 }
4790
4791 if (flagLEP2[WeakBox]) {
4792 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm207, &(*this), _1));
4793 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4794 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4795 }
4796 double sigma_box = average;
4797 SMresult_cache += sigma_box;
4798 }
4799 } else {
4800 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2sigmaCharm!");
4801 }
4802
4803
4804 double sigma_mu = SMresult_cache;
4805
4806 gsl_set_error_handler(old_handler);
4807
4808 return sigma_mu;
4809
4810}
const double getIntegrand_sigmaWithISR_charm192(double x) const
const double getIntegrand_sigmaWithISR_charm183(double x) const
const double getIntegrand_sigmaWithISR_charm205(double x) const
const double getIntegrand_sigmaWithISR_charm207(double x) const
const double getIntegrand_sigmaWithISR_charm202(double x) const
const double getIntegrand_sigmaWithISR_charm200(double x) const
const double getIntegrand_sigmaWithISR_charm133(double x) const
const double getIntegrand_sigmaWithISR_charm167(double x) const
const double getIntegrand_sigmaWithISR_charm196(double x) const
const double getIntegrand_sigmaWithISR_charm189(double x) const

◆ LEP2sigmaE()

const double StandardModel::LEP2sigmaE ( const double  s) const
virtual

Reimplemented in NPbase.

Definition at line 4082 of file StandardModel/src/StandardModel.cpp.

4083{
4084 return 0.;
4085}

◆ LEP2sigmaHadron()

const double StandardModel::LEP2sigmaHadron ( const double  s) const
virtual

Reimplemented in NPbase, and NPSTUVWXY.

Definition at line 5024 of file StandardModel/src/StandardModel.cpp.

5025{
5026 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
5027 double relerr = 1.e-8;
5028 double abserr = 1.e-20;
5029
5030 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
5032
5033 /* SM contribution with the approximate formula */
5035
5036 } else {
5037
5038 if(s == 130.*130.){
5039
5040 if (!flagLEP2[ISR]){
5046 } else {
5047
5048 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up130, &(*this), _1));
5049 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5050 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5051 }
5053
5054 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down130, &(*this), _1));
5055 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5056 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5057 }
5059
5060 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm130, &(*this), _1));
5061 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5062 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5063 }
5065
5066 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange130, &(*this), _1));
5067 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5068 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5069 }
5071
5072 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom130, &(*this), _1));
5073 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5074 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5075 }
5077
5078 }
5079
5080 if (flagLEP2[WeakBox]) {
5081 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up130, &(*this), _1));
5082 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5083 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5084 }
5085 double sigma_box = average;
5086
5087 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down130, &(*this), _1));
5088 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5089 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5090 }
5091 sigma_box += average;
5092
5093 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm130, &(*this), _1));
5094 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5095 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5096 }
5097 sigma_box += average;
5098
5099 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange130, &(*this), _1));
5100 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5101 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5102 }
5103 sigma_box += average;
5104
5105 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom130, &(*this), _1));
5106 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5107 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5108 }
5109 sigma_box += average;
5110 SMresult_cache += sigma_box;
5111 }
5112 } else if (s == 133.*133.) {
5113 if (!flagLEP2[ISR]){
5119 } else {
5120
5121 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up133, &(*this), _1));
5122 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5123 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5124 }
5126
5127 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down133, &(*this), _1));
5128 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5129 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5130 }
5132
5133 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm133, &(*this), _1));
5134 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5135 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5136 }
5138
5139 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange133, &(*this), _1));
5140 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5141 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5142 }
5144
5145 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom133, &(*this), _1));
5146 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5147 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5148 }
5150 }
5151
5152 if (flagLEP2[WeakBox]) {
5153 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up133, &(*this), _1));
5154 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5155 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5156 }
5157 double sigma_box = average;
5158
5159 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down133, &(*this), _1));
5160 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5161 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5162 }
5163 sigma_box += average;
5164
5165 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm133, &(*this), _1));
5166 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5167 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5168 }
5169 sigma_box += average;
5170
5171 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange133, &(*this), _1));
5172 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5173 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5174 }
5175 sigma_box += average;
5176
5177 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom133, &(*this), _1));
5178 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5179 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5180 }
5181 sigma_box += average;
5182 SMresult_cache += sigma_box;
5183 }
5184 } else if (s == 136.*136.) {
5185 if (!flagLEP2[ISR]){
5191 } else {
5192
5193 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up136, &(*this), _1));
5194 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5195 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5196 }
5198
5199 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down136, &(*this), _1));
5200 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5201 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5202 }
5204
5205 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm136, &(*this), _1));
5206 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5207 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5208 }
5210
5211 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange136, &(*this), _1));
5212 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5213 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5214 }
5216
5217 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom136, &(*this), _1));
5218 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5219 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5220 }
5222 }
5223
5224 if (flagLEP2[WeakBox]) {
5225 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up136, &(*this), _1));
5226 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5227 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5228 }
5229 double sigma_box = average;
5230
5231 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down136, &(*this), _1));
5232 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5233 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5234 }
5235 sigma_box += average;
5236
5237 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm136, &(*this), _1));
5238 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5239 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5240 }
5241 sigma_box += average;
5242
5243 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange136, &(*this), _1));
5244 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5245 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5246 }
5247 sigma_box += average;
5248
5249 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom136, &(*this), _1));
5250 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5251 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5252 }
5253 sigma_box += average;
5254 SMresult_cache += sigma_box;
5255 }
5256 } else if (s == 161.*161.){
5257 if (!flagLEP2[ISR]){
5263 } else {
5264
5265 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up161, &(*this), _1));
5266 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5267 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5268 }
5270
5271 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down161, &(*this), _1));
5272 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5273 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5274 }
5276
5277 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm161, &(*this), _1));
5278 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, 1.e-12, 1.e-6, 100, w_GSL1, &average, &error) != 0){
5279 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5280 }
5282
5283 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange161, &(*this), _1));
5284 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 200, w_GSL1, &average, &error) != 0){
5285 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5286 }
5288
5289 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom161, &(*this), _1));
5290 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5291 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5292 }
5294 }
5295
5296 if (flagLEP2[WeakBox]) {
5297 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up161, &(*this), _1));
5298 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5299 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5300 }
5301 double sigma_box = average;
5302
5303 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down161, &(*this), _1));
5304 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5305 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5306 }
5307 sigma_box += average;
5308
5309 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm161, &(*this), _1));
5310 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5311 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5312 }
5313 sigma_box += average;
5314
5315 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange161, &(*this), _1));
5316 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5317 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5318 }
5319 sigma_box += average;
5320
5321 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom161, &(*this), _1));
5322 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5323 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5324 }
5325 sigma_box += average;
5326 SMresult_cache += sigma_box;
5327 }
5328 } else if (s == 167.*167.) {
5329 if (!flagLEP2[ISR]){
5335 } else {
5336
5337 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up167, &(*this), _1));
5338 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5339 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5340 }
5341
5343
5344 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down167, &(*this), _1));
5345 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, 1.e-15, 1.e-9, 200, w_GSL1, &average, &error) != 0){
5346 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5347 }
5349
5350 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm167, &(*this), _1));
5351 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, 1.e-15, 1.e-9, 200, w_GSL1, &average, &error) != 0){
5352 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5353 }
5355
5356 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange167, &(*this), _1));
5357 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, 1.e-15, 1.e-9, 200, w_GSL1, &average, &error) != 0){
5358 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5359 }
5361
5362 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom167, &(*this), _1));
5363 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, 1.e-15, 1.e-9, 200, w_GSL1, &average, &error) != 0){
5364 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5365 }
5367 }
5368
5369 if (flagLEP2[WeakBox]) {
5370 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up167, &(*this), _1));
5371 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5372 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5373 }
5374 double sigma_box = average;
5375
5376 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down167, &(*this), _1));
5377 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5378 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5379 }
5380 sigma_box += average;
5381
5382 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm167, &(*this), _1));
5383 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5384 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5385 }
5386 sigma_box += average;
5387
5388 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange167, &(*this), _1));
5389 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5390 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5391 }
5392 sigma_box += average;
5393
5394 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom167, &(*this), _1));
5395 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5396 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5397 }
5398 sigma_box += average;
5399 SMresult_cache += sigma_box;
5400 }
5401 } else if (s == 172.*172.) {
5402 if (!flagLEP2[ISR]){
5408 } else {
5409
5410 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up172, &(*this), _1));
5411 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5412 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5413 }
5415
5416 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down172, &(*this), _1));
5417 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5418 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5419 }
5421
5422 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm172, &(*this), _1));
5423 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5424 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5425 }
5427
5428 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange172, &(*this), _1));
5429 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5430 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5431 }
5433
5434 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom172, &(*this), _1));
5435 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5436 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5437 }
5439 }
5440
5441 if (flagLEP2[WeakBox]) {
5442 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up172, &(*this), _1));
5443 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5444 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5445 }
5446 double sigma_box = average;
5447
5448 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down172, &(*this), _1));
5449 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5450 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5451 }
5452 sigma_box += average;
5453
5454 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm172, &(*this), _1));
5455 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5456 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5457 }
5458 sigma_box += average;
5459
5460 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange172, &(*this), _1));
5461 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5462 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5463 }
5464 sigma_box += average;
5465
5466 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom172, &(*this), _1));
5467 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5468 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5469 }
5470 sigma_box += average;
5471 SMresult_cache += sigma_box;
5472 }
5473 } else if (s == 183.*183.) {
5474 if (!flagLEP2[ISR]){
5480 } else {
5481
5482 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up183, &(*this), _1));
5483 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5484 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5485 }
5487
5488 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down183, &(*this), _1));
5489 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5490 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5491 }
5493
5494 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm183, &(*this), _1));
5495 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5496 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5497 }
5499
5500 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange183, &(*this), _1));
5501 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5502 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5503 }
5505
5506 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom183, &(*this), _1));
5507 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5508 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5509 }
5511 }
5512
5513 if (flagLEP2[WeakBox]) {
5514 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up183, &(*this), _1));
5515 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5516 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5517 }
5518 double sigma_box = average;
5519
5520 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down183, &(*this), _1));
5521 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5522 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5523 }
5524 sigma_box += average;
5525
5526 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm183, &(*this), _1));
5527 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5528 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5529 }
5530 sigma_box += average;
5531
5532 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange183, &(*this), _1));
5533 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5534 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5535 }
5536 sigma_box += average;
5537
5538 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom183, &(*this), _1));
5539 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5540 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5541 }
5542 sigma_box += average;
5543 SMresult_cache += sigma_box;
5544 }
5545 } else if (s == 189.*189.) {
5546 if (!flagLEP2[ISR]){
5552 } else {
5553
5554 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up189, &(*this), _1));
5555 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5556 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5557 }
5559
5560 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down189, &(*this), _1));
5561 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5562 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5563 }
5565
5566 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm189, &(*this), _1));
5567 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5568 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5569 }
5571
5572 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange189, &(*this), _1));
5573 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5574 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5575 }
5577
5578 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom189, &(*this), _1));
5579 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5580 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5581 }
5583 }
5584
5585 if (flagLEP2[WeakBox]) {
5586 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up189, &(*this), _1));
5587 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5588 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5589 }
5590 double sigma_box = average;
5591
5592 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down189, &(*this), _1));
5593 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5594 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5595 }
5596 sigma_box += average;
5597
5598 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm189, &(*this), _1));
5599 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5600 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5601 }
5602 sigma_box += average;
5603
5604 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange189, &(*this), _1));
5605 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5606 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5607 }
5608 sigma_box += average;
5609
5610 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom189, &(*this), _1));
5611 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5612 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5613 }
5614 sigma_box += average;
5615 SMresult_cache += sigma_box;
5616 }
5617 } else if (s == 192.*192.) {
5618 if (!flagLEP2[ISR]){
5624 } else {
5625
5626 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up192, &(*this), _1));
5627 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5628 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5629 }
5631
5632 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down192, &(*this), _1));
5633 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5634 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5635 }
5637
5638 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm192, &(*this), _1));
5639
5640 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5641 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5642 }
5644
5645 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange192, &(*this), _1));
5646
5647 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5648 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5649 }
5651
5652 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom192, &(*this), _1));
5653 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5654 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5655 }
5657 }
5658
5659 if (flagLEP2[WeakBox]) {
5660 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up192, &(*this), _1));
5661 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5662 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5663 }
5664 double sigma_box = average;
5665
5666 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down192, &(*this), _1));
5667 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5668 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5669 }
5670 sigma_box += average;
5671
5672 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm192, &(*this), _1));
5673 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5674 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5675 }
5676 sigma_box += average;
5677
5678 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange192, &(*this), _1));
5679 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5680 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5681 }
5682 sigma_box += average;
5683
5684 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom192, &(*this), _1));
5685 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5686 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5687 }
5688 sigma_box += average;
5689 SMresult_cache += sigma_box;
5690 }
5691 } else if (s == 196.*196.) {
5692 if (!flagLEP2[ISR]){
5698 } else {
5699
5700 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up196, &(*this), _1));
5701 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5702 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5703 }
5705
5706 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down196, &(*this), _1));
5707 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5708 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5709 }
5711
5712 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm196, &(*this), _1));
5713 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5714 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5715 }
5717
5718 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange196, &(*this), _1));
5719
5720 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5721 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5722 }
5724
5725 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom196, &(*this), _1));
5726 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5727 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5728 }
5730 }
5731
5732 if (flagLEP2[WeakBox]) {
5733 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up196, &(*this), _1));
5734 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5735 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5736 }
5737 double sigma_box = average;
5738
5739 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down196, &(*this), _1));
5740 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5741 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5742 }
5743 sigma_box += average;
5744
5745 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm196, &(*this), _1));
5746 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5747 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5748 }
5749 sigma_box += average;
5750
5751 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange196, &(*this), _1));
5752 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5753 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5754 }
5755 sigma_box += average;
5756
5757 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom196, &(*this), _1));
5758 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5759 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5760 }
5761 sigma_box += average;
5762 SMresult_cache += sigma_box;
5763 }
5764 } else if (s == 200.*200.) {
5765 if (!flagLEP2[ISR]){
5771 } else {
5772
5773 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up200, &(*this), _1));
5774 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5775 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5776 }
5778
5779 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down200, &(*this), _1));
5780 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5781 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5782 }
5784
5785 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm200, &(*this), _1));
5786 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5787 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5788 }
5790
5791 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange200, &(*this), _1));
5792 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5793 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5794 }
5796
5797 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom200, &(*this), _1));
5798 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5799 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5800 }
5802 }
5803
5804 if (flagLEP2[WeakBox]) {
5805 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up200, &(*this), _1));
5806 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5807 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5808 }
5809 double sigma_box = average;
5810
5811 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down200, &(*this), _1));
5812 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5813 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5814 }
5815 sigma_box += average;
5816
5817 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm200, &(*this), _1));
5818 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5819 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5820 }
5821 sigma_box += average;
5822
5823 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange200, &(*this), _1));
5824 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5825 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5826 }
5827 sigma_box += average;
5828
5829 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom200, &(*this), _1));
5830 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5831 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5832 }
5833 sigma_box += average;
5834 SMresult_cache += sigma_box;
5835 }
5836 } else if (s == 202.*202.) {
5837 if (!flagLEP2[ISR]){
5843 } else {
5844
5845 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up202, &(*this), _1));
5846
5847
5848
5849 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5850 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5851 }
5853
5854 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down202, &(*this), _1));
5855
5856
5857
5858 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5859 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5860 }
5862
5863 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm202, &(*this), _1));
5864
5865
5866
5867 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5868 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5869 }
5871
5872 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange202, &(*this), _1));
5873
5874
5875
5876 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5877 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5878 }
5880
5881 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom202, &(*this), _1));
5882
5883
5884
5885 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5886 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5887 }
5889 }
5890
5891 if (flagLEP2[WeakBox]) {
5892 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up202, &(*this), _1));
5893
5894
5895
5896 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5897 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5898 }
5899 double sigma_box = average;
5900
5901 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down202, &(*this), _1));
5902
5903
5904
5905 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5906 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5907 }
5908 sigma_box += average;
5909
5910 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm202, &(*this), _1));
5911
5912
5913
5914 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5915 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5916 }
5917 sigma_box += average;
5918
5919 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange202, &(*this), _1));
5920
5921
5922
5923 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5924 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5925 }
5926 sigma_box += average;
5927
5928 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom202, &(*this), _1));
5929
5930
5931
5932 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5933 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5934 }
5935 sigma_box += average;
5936 SMresult_cache += sigma_box;
5937 }
5938 } else if (s == 205.*205.) {
5939 if (!flagLEP2[ISR]){
5945 } else {
5946
5947 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up205, &(*this), _1));
5948
5949
5950
5951 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5952 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5953 }
5955
5956 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down205, &(*this), _1));
5957
5958
5959
5960 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5961 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5962 }
5964
5965 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm205, &(*this), _1));
5966
5967
5968
5969 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5970 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5971 }
5973
5974 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange205, &(*this), _1));
5975
5976
5977
5978 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5979 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5980 }
5982
5983 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom205, &(*this), _1));
5984
5985
5986
5987 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5988 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5989 }
5991 }
5992
5993 if (flagLEP2[WeakBox]) {
5994 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up205, &(*this), _1));
5995
5996
5997
5998 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5999 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6000 }
6001 double sigma_box = average;
6002
6003 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down205, &(*this), _1));
6004
6005
6006
6007 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6008 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6009 }
6010 sigma_box += average;
6011
6012 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm205, &(*this), _1));
6013
6014
6015
6016 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6017 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6018 }
6019 sigma_box += average;
6020
6021 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange205, &(*this), _1));
6022
6023
6024
6025 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6026 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6027 }
6028 sigma_box += average;
6029
6030 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom205, &(*this), _1));
6031
6032
6033
6034 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6035 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6036 }
6037 sigma_box += average;
6038 SMresult_cache += sigma_box;
6039 }
6040 } else if (s == 207.*207.) {
6041 if (!flagLEP2[ISR]){
6047 } else {
6048
6049 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up207, &(*this), _1));
6050
6051
6052
6053 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6054 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6055 }
6057
6058 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down207, &(*this), _1));
6059
6060
6061
6062 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6063 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6064 }
6066
6067 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm207, &(*this), _1));
6068
6069
6070
6071 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6072 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6073 }
6075
6076 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange207, &(*this), _1));
6077
6078
6079
6080 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6081 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6082 }
6084
6085 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom207, &(*this), _1));
6086
6087
6088
6089 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6090 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6091 }
6093 }
6094
6095 if (flagLEP2[WeakBox]) {
6096 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up207, &(*this), _1));
6097
6098
6099
6100 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6101 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6102 }
6103 double sigma_box = average;
6104
6105 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down207, &(*this), _1));
6106
6107
6108
6109 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6110 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6111 }
6112 sigma_box += average;
6113
6114 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm207, &(*this), _1));
6115
6116
6117
6118 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6119 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6120 }
6121 sigma_box += average;
6122
6123 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange207, &(*this), _1));
6124
6125
6126
6127 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6128 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6129 }
6130 sigma_box += average;
6131
6132 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom207, &(*this), _1));
6133
6134
6135
6136 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6137 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6138 }
6139 sigma_box += average;
6140 SMresult_cache += sigma_box;
6141 }
6142 } else {
6143 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2sigmaHadron!");
6144 }
6145
6146 double sigma_had = SMresult_cache;
6147
6148 gsl_set_error_handler(old_handler);
6149
6150 return sigma_had;
6151
6152 }
6153}
double LEP2sigmaHadronApprox(const double s) const
The cross section at LEP2.
const double getIntegrand_sigmaWithISR_down183(double x) const
const double getIntegrand_dsigmaBox_strange167(double x) const
const double getIntegrand_sigmaWithISR_strange167(double x) const
const double getIntegrand_sigmaWithISR_strange189(double x) const
const double getIntegrand_sigmaWithISR_strange161(double x) const
const double getIntegrand_dsigmaBox_up130(double x) const
const double getIntegrand_dsigmaBox_down207(double x) const
const double getIntegrand_dsigmaBox_down200(double x) const
const double getIntegrand_dsigmaBox_strange172(double x) const
const double getIntegrand_dsigmaBox_up202(double x) const
const double getIntegrand_sigmaWithISR_down192(double x) const
const double getIntegrand_dsigmaBox_strange130(double x) const
const double getIntegrand_sigmaWithISR_strange136(double x) const
const double getIntegrand_sigmaWithISR_down207(double x) const
const double getIntegrand_dsigmaBox_down136(double x) const
const double getIntegrand_dsigmaBox_strange189(double x) const
const double getIntegrand_sigmaWithISR_up183(double x) const
const double getIntegrand_sigmaWithISR_strange183(double x) const
const double getIntegrand_dsigmaBox_down183(double x) const
const double getIntegrand_dsigmaBox_charm130(double x) const
const double getIntegrand_sigmaWithISR_strange200(double x) const
const double getIntegrand_sigmaWithISR_up167(double x) const
const double getIntegrand_sigmaWithISR_strange207(double x) const
const double getIntegrand_dsigmaBox_down161(double x) const
const double getIntegrand_dsigmaBox_strange207(double x) const
const double getIntegrand_sigmaWithISR_down202(double x) const
const double getIntegrand_dsigmaBox_charm161(double x) const
const double getIntegrand_dsigmaBox_up192(double x) const
const double getIntegrand_sigmaWithISR_strange202(double x) const
const double getIntegrand_dsigmaBox_down202(double x) const
const double getIntegrand_dsigmaBox_up200(double x) const
const double getIntegrand_sigmaWithISR_bottom136(double x) const
const double getIntegrand_sigmaWithISR_bottom130(double x) const
const double getIntegrand_sigmaWithISR_charm161(double x) const
const double getIntegrand_sigmaWithISR_charm172(double x) const
const double getIntegrand_dsigmaBox_up167(double x) const
const double getIntegrand_dsigmaBox_strange200(double x) const
const double getIntegrand_dsigmaBox_strange196(double x) const
const double getIntegrand_dsigmaBox_up207(double x) const
const double getIntegrand_sigmaWithISR_down200(double x) const
const double getIntegrand_sigmaWithISR_charm130(double x) const
const double getIntegrand_sigmaWithISR_down196(double x) const
const double getIntegrand_sigmaWithISR_bottom172(double x) const
const double getIntegrand_sigmaWithISR_up133(double x) const
const double getIntegrand_dsigmaBox_down189(double x) const
const double getIntegrand_sigmaWithISR_up172(double x) const
const double getIntegrand_dsigmaBox_up161(double x) const
const double getIntegrand_sigmaWithISR_strange205(double x) const
const double getIntegrand_dsigmaBox_bottom172(double x) const
const double getIntegrand_dsigmaBox_down133(double x) const
const double getIntegrand_dsigmaBox_down167(double x) const
const double getIntegrand_sigmaWithISR_strange133(double x) const
const double getIntegrand_sigmaWithISR_down130(double x) const
const double getIntegrand_sigmaWithISR_strange192(double x) const
const double getIntegrand_dsigmaBox_bottom130(double x) const
const double getIntegrand_sigmaWithISR_strange130(double x) const
const double getIntegrand_dsigmaBox_strange161(double x) const
const double getIntegrand_sigmaWithISR_down136(double x) const
const double getIntegrand_sigmaWithISR_up192(double x) const
const double getIntegrand_dsigmaBox_strange205(double x) const
const double getIntegrand_sigmaWithISR_up200(double x) const
const double getIntegrand_dsigmaBox_up183(double x) const
const double getIntegrand_dsigmaBox_strange183(double x) const
const double getIntegrand_dsigmaBox_up133(double x) const
const double getIntegrand_sigmaWithISR_strange172(double x) const
const double getIntegrand_dsigmaBox_strange202(double x) const
const double getIntegrand_sigmaWithISR_up189(double x) const
const double getIntegrand_dsigmaBox_down172(double x) const
const double getIntegrand_dsigmaBox_strange136(double x) const
const double getIntegrand_sigmaWithISR_up136(double x) const
const double getIntegrand_sigmaWithISR_strange196(double x) const
const double getIntegrand_dsigmaBox_up205(double x) const
const double getIntegrand_sigmaWithISR_up202(double x) const
const double getIntegrand_sigmaWithISR_down167(double x) const
const double getIntegrand_sigmaWithISR_down133(double x) const
const double getIntegrand_sigmaWithISR_charm136(double x) const
const double getIntegrand_dsigmaBox_down130(double x) const
const double getIntegrand_dsigmaBox_strange192(double x) const
const double getIntegrand_sigmaWithISR_down189(double x) const
const double getIntegrand_dsigmaBox_bottom161(double x) const
const double getIntegrand_sigmaWithISR_up207(double x) const
const double getIntegrand_dsigmaBox_charm172(double x) const
const double getIntegrand_dsigmaBox_charm136(double x) const
const double getIntegrand_sigmaWithISR_up205(double x) const
const double getIntegrand_dsigmaBox_down196(double x) const
const double getIntegrand_sigmaWithISR_up161(double x) const
const double getIntegrand_sigmaWithISR_down172(double x) const
const double getIntegrand_dsigmaBox_strange133(double x) const
const double getIntegrand_sigmaWithISR_up196(double x) const
const double getIntegrand_dsigmaBox_up196(double x) const
const double getIntegrand_sigmaWithISR_bottom161(double x) const
const double getIntegrand_dsigmaBox_up189(double x) const
const double getIntegrand_dsigmaBox_up136(double x) const
const double getIntegrand_sigmaWithISR_down205(double x) const
const double getIntegrand_dsigmaBox_up172(double x) const
const double getIntegrand_sigmaWithISR_up130(double x) const
const double getIntegrand_dsigmaBox_down205(double x) const
const double getIntegrand_dsigmaBox_down192(double x) const
const double getIntegrand_sigmaWithISR_down161(double x) const
const double getIntegrand_dsigmaBox_bottom136(double x) const

◆ LEP2sigmaMu()

const double StandardModel::LEP2sigmaMu ( const double  s) const
virtual

Reimplemented in NPbase, and NPSTUVWXY.

Definition at line 4087 of file StandardModel/src/StandardModel.cpp.

4088{
4089 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
4090 double relerr = 1.e-8;
4091 double abserr = 1.e-20;
4092
4093 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
4095
4096 /* SM contribution with the approximate formula */
4098
4099 } else {
4100
4101 if(s == 130.*130.){
4102
4103 if (!flagLEP2[ISR]){
4105 } else {
4106 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu130, &(*this), _1));
4107 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4108 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4109 }
4111 }
4112
4113 if (flagLEP2[WeakBox]) {
4114 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu130, &(*this), _1));
4115 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4116 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4117 }
4118 double sigma_box = average;
4119 SMresult_cache += sigma_box;
4120 }
4121 } else if (s == 136.*136.) {
4122 if (!flagLEP2[ISR]){
4124 } else {
4125 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu136, &(*this), _1));
4126 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4127 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4128 }
4130 }
4131
4132 if (flagLEP2[WeakBox]) {
4133 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu136, &(*this), _1));
4134 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4135 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4136 }
4137 double sigma_box = average;
4138 SMresult_cache += sigma_box;
4139 }
4140 } else if (s == 161.*161.){
4141 if (!flagLEP2[ISR])
4143 else {
4144 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu161, &(*this), _1));
4145 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4146 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4147 }
4149 }
4150
4151 if (flagLEP2[WeakBox]) {
4152 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu161, &(*this), _1));
4153 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4154 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4155 }
4156 double sigma_box = average;
4157 SMresult_cache += sigma_box;
4158 }
4159 } else if (s == 172.*172.) {
4160 if (!flagLEP2[ISR])
4162 else {
4163 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu172, &(*this), _1));
4164 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4165 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4166 }
4168 }
4169
4170 if (flagLEP2[WeakBox]) {
4171 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu172, &(*this), _1));
4172 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4173 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4174 }
4175 double sigma_box = average;
4176 SMresult_cache += sigma_box;
4177 }
4178 } else if (s == 183.*183.) {
4179 if (!flagLEP2[ISR])
4181 else {
4182 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu183, &(*this), _1));
4183 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4184 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4185 }
4187 }
4188
4189 if (flagLEP2[WeakBox]) {
4190 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu183, &(*this), _1));
4191 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4192 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4193 }
4194 double sigma_box = average;
4195 SMresult_cache += sigma_box;
4196 }
4197 } else if (s == 189.*189.) {
4198 if (!flagLEP2[ISR])
4200 else {
4201 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu189, &(*this), _1));
4202 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4203 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4204 }
4206 }
4207
4208 if (flagLEP2[WeakBox]) {
4209 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu189, &(*this), _1));
4210 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4211 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4212 }
4213 double sigma_box = average;
4214 SMresult_cache += sigma_box;
4215 }
4216 } else if (s == 192.*192.) {
4217 if (!flagLEP2[ISR])
4219 else {
4220 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu192, &(*this), _1));
4221 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4222 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4223 }
4225 }
4226
4227 if (flagLEP2[WeakBox]) {
4228 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu192, &(*this), _1));
4229 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4230 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4231 }
4232 double sigma_box = average;
4233 SMresult_cache += sigma_box;
4234 }
4235 } else if (s == 196.*196.) {
4236 if (!flagLEP2[ISR])
4238 else {
4239 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu196, &(*this), _1));
4240 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4241 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4242 }
4244 }
4245
4246 if (flagLEP2[WeakBox]) {
4247 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu196, &(*this), _1));
4248 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4249 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4250 }
4251 double sigma_box = average;
4252 SMresult_cache += sigma_box;
4253 }
4254 } else if (s == 200.*200.) {
4255 if (!flagLEP2[ISR])
4257 else {
4258 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu200, &(*this), _1));
4259 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4260 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4261 }
4263 }
4264
4265 if (flagLEP2[WeakBox]) {
4266 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu200, &(*this), _1));
4267 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4268 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4269 }
4270 double sigma_box = average;
4271 SMresult_cache += sigma_box;
4272 }
4273 } else if (s == 202.*202.) {
4274 if (!flagLEP2[ISR])
4276 else {
4277 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu202, &(*this), _1));
4278 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4279 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4280 }
4282 }
4283
4284 if (flagLEP2[WeakBox]) {
4285 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu202, &(*this), _1));
4286 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4287 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4288 }
4289 double sigma_box = average;
4290 SMresult_cache += sigma_box;
4291 }
4292 } else if (s == 205.*205.) {
4293 if (!flagLEP2[ISR])
4295 else {
4296 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu205, &(*this), _1));
4297 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4298 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4299 }
4301 }
4302
4303 if (flagLEP2[WeakBox]) {
4304 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu205, &(*this), _1));
4305 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4306 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4307 }
4308 double sigma_box = average;
4309 SMresult_cache += sigma_box;
4310 }
4311 } else if (s == 207.*207.) {
4312 if (!flagLEP2[ISR])
4314 else {
4315 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu207, &(*this), _1));
4316 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4317 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4318 }
4320 }
4321
4322 if (flagLEP2[WeakBox]) {
4323 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu207, &(*this), _1));
4324 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4325 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4326 }
4327 double sigma_box = average;
4328 SMresult_cache += sigma_box;
4329 }
4330 } else {
4331 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2AFBmu!");
4332 }
4333
4334 double sigma_mu = SMresult_cache;
4335
4336 gsl_set_error_handler(old_handler);
4337
4338 return sigma_mu;
4339
4340 }
4341}
double LEP2sigmaMuApprox(const double s) const
The cross section at LEP2.
const double getIntegrand_sigmaWithISR_mu207(double x) const
const double getIntegrand_sigmaWithISR_mu172(double x) const
const double getIntegrand_sigmaWithISR_mu136(double x) const
const double getIntegrand_sigmaWithISR_mu161(double x) const
const double sigma_NoISR_l(const QCD::lepton l_flavor, const double s) const
const double getIntegrand_sigmaWithISR_mu130(double x) const
const double getIntegrand_sigmaWithISR_mu202(double x) const
const double getIntegrand_sigmaWithISR_mu205(double x) const
const double getIntegrand_sigmaWithISR_mu189(double x) const
const double getIntegrand_sigmaWithISR_mu196(double x) const
const double getIntegrand_sigmaWithISR_mu200(double x) const
const double getIntegrand_sigmaWithISR_mu183(double x) const
const double getIntegrand_sigmaWithISR_mu192(double x) const

◆ LEP2sigmaTau()

const double StandardModel::LEP2sigmaTau ( const double  s) const
virtual

Reimplemented in NPbase, and NPSTUVWXY.

Definition at line 4344 of file StandardModel/src/StandardModel.cpp.

4345{
4346
4347 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
4348 double relerr = 1.e-7;
4349 double abserr = 1.e-17;
4350
4351 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
4353
4354 /* SM contribution with the approximate formula */
4356
4357 } else {
4358
4359 if(s == 130.*130.){
4360
4361 if (!flagLEP2[ISR]){
4363 } else {
4364 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau130, &(*this), _1));
4365 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4366 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4367 }
4369 }
4370
4371 if (flagLEP2[WeakBox]) {
4372 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau130, &(*this), _1));
4373 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4374 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4375 }
4376 double sigma_box = average;
4377 SMresult_cache += sigma_box;
4378 }
4379 } else if (s == 136.*136.) {
4380 if (!flagLEP2[ISR]){
4382 } else {
4383 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau136, &(*this), _1));
4384 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4385 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4386 }
4388 }
4389
4390 if (flagLEP2[WeakBox]) {
4391 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau136, &(*this), _1));
4392 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4393 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4394 }
4395 double sigma_box = average;
4396 SMresult_cache += sigma_box;
4397 }
4398 } else if (s == 161.*161.){
4399 if (!flagLEP2[ISR])
4401 else {
4402 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau161, &(*this), _1));
4403 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4404 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4405 }
4407 }
4408
4409 if (flagLEP2[WeakBox]) {
4410 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau161, &(*this), _1));
4411 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4412 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4413 }
4414 double sigma_box = average;
4415 SMresult_cache += sigma_box;
4416 }
4417 } else if (s == 172.*172.) {
4418 if (!flagLEP2[ISR])
4420 else {
4421 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau172, &(*this), _1));
4422 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4423 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4424 }
4426 }
4427
4428 if (flagLEP2[WeakBox]) {
4429 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau172, &(*this), _1));
4430 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4431 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4432 }
4433 double sigma_box = average;
4434 SMresult_cache += sigma_box;
4435 }
4436 } else if (s == 183.*183.) {
4437 if (!flagLEP2[ISR])
4439 else {
4440 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau183, &(*this), _1));
4441 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4442 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4443 }
4445 }
4446
4447 if (flagLEP2[WeakBox]) {
4448 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau183, &(*this), _1));
4449 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4450 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4451 }
4452 double sigma_box = average;
4453 SMresult_cache += sigma_box;
4454 }
4455 } else if (s == 189.*189.) {
4456 if (!flagLEP2[ISR])
4458 else {
4459 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau189, &(*this), _1));
4460 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4461 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4462 }
4464 }
4465
4466 if (flagLEP2[WeakBox]) {
4467 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau189, &(*this), _1));
4468 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4469 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4470 }
4471 double sigma_box = average;
4472 SMresult_cache += sigma_box;
4473 }
4474 } else if (s == 192.*192.) {
4475 if (!flagLEP2[ISR])
4477 else {
4478 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau192, &(*this), _1));
4479 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4480 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4481 }
4483 }
4484
4485 if (flagLEP2[WeakBox]) {
4486 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau192, &(*this), _1));
4487 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4488 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4489 }
4490 double sigma_box = average;
4491 SMresult_cache += sigma_box;
4492 }
4493 } else if (s == 196.*196.) {
4494 if (!flagLEP2[ISR])
4496 else {
4497 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau196, &(*this), _1));
4498 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4499 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4500 }
4502 }
4503
4504 if (flagLEP2[WeakBox]) {
4505 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau196, &(*this), _1));
4506 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4507 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4508 }
4509 double sigma_box = average;
4510 SMresult_cache += sigma_box;
4511 }
4512 } else if (s == 200.*200.) {
4513 if (!flagLEP2[ISR])
4515 else {
4516 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau200, &(*this), _1));
4517 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4518 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4519 }
4521 }
4522
4523 if (flagLEP2[WeakBox]) {
4524 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau200, &(*this), _1));
4525 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4526 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4527 }
4528 double sigma_box = average;
4529 SMresult_cache += sigma_box;
4530 }
4531 } else if (s == 202.*202.) {
4532 if (!flagLEP2[ISR])
4534 else {
4535 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau202, &(*this), _1));
4536 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4537 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4538 }
4540 }
4541
4542 if (flagLEP2[WeakBox]) {
4543 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau202, &(*this), _1));
4544 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4545 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4546 }
4547 double sigma_box = average;
4548 SMresult_cache += sigma_box;
4549 }
4550 } else if (s == 205.*205.) {
4551 if (!flagLEP2[ISR])
4553 else {
4554 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau205, &(*this), _1));
4555 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4556 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4557 }
4559 }
4560
4561 if (flagLEP2[WeakBox]) {
4562 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau205, &(*this), _1));
4563 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4564 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4565 }
4566 double sigma_box = average;
4567 SMresult_cache += sigma_box;
4568 }
4569 } else if (s == 207.*207.) {
4570 if (!flagLEP2[ISR])
4572 else {
4573 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau207, &(*this), _1));
4574 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4575 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4576 }
4578 }
4579
4580 if (flagLEP2[WeakBox]) {
4581 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau207, &(*this), _1));
4582 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4583 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4584 }
4585 double sigma_box = average;
4586 SMresult_cache += sigma_box;
4587 }
4588 } else {
4589 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2sigmaTau!");
4590 }
4591
4592 double sigma_tau = SMresult_cache;
4593
4594 gsl_set_error_handler(old_handler);
4595
4596 return sigma_tau;
4597
4598 }
4599}
double LEP2sigmaTauApprox(const double s) const
The cross section at LEP2.
const double getIntegrand_sigmaWithISR_tau207(double x) const
const double getIntegrand_sigmaWithISR_tau205(double x) const
const double getIntegrand_sigmaWithISR_tau196(double x) const
const double getIntegrand_sigmaWithISR_tau161(double x) const
const double getIntegrand_sigmaWithISR_tau183(double x) const
const double getIntegrand_sigmaWithISR_tau130(double x) const
const double getIntegrand_sigmaWithISR_tau200(double x) const
const double getIntegrand_sigmaWithISR_tau189(double x) const
const double getIntegrand_sigmaWithISR_tau192(double x) const
const double getIntegrand_sigmaWithISR_tau136(double x) const
const double getIntegrand_sigmaWithISR_tau202(double x) const
const double getIntegrand_sigmaWithISR_tau172(double x) const

◆ m_q()

double StandardModel::m_q ( const QCD::quark  q,
const double  mu,
const orders  order = FULLNLO 
) const
inlineprotected

Definition at line 3513 of file StandardModel.h.

3514 {
3515 switch(q) {
3516 case QCD::UP:
3517 case QCD::DOWN:
3518 case QCD::STRANGE:
3519 return Mrun(mu, getQuarks(q).getMass_scale(),
3520 getQuarks(q).getMass(), q, order);
3521 case QCD::CHARM:
3522 case QCD::BOTTOM:
3523 case QCD::TOP:
3524 return Mrun(mu, getQuarks(q).getMass(), q, order);
3525 default:
3526 throw std::runtime_error("Error in StandardModel::m_q()");
3527 }
3528 }

◆ MLL2eeff()

const double StandardModel::MLL2eeff ( const Particle  f,
const double  s,
const double  t 
) const

Definition at line 3805 of file StandardModel/src/StandardModel.cpp.

3805 {
3806
3807 // Definitions
3808 double Qf, geLSM, gfLSM, is2c2, GZ, Mz2s;
3809
3810 double MLL2SM;
3811
3812 // -------------------------------------------
3813
3814 geLSM = (leptons[ELECTRON].getIsospin()) - (leptons[ELECTRON].getCharge()) * s02();
3815
3816 is2c2 = 1. / s02() / c02();
3817
3818 GZ = Gamma_Z();
3819
3820 Mz2s = Mz * Mz - s;
3821
3822 if (f.is("ELECTRON")) {
3823 Qf = leptons[ELECTRON].getCharge();
3824 gfLSM = (leptons[ELECTRON].getIsospin()) - Qf * s02();
3825 } else if (f.is("MU")) {
3826 Qf = leptons[MU].getCharge();
3827 gfLSM = (leptons[MU].getIsospin()) - Qf * s02();
3828 } else if (f.is("TAU")) {
3829 Qf = leptons[TAU].getCharge();
3830 gfLSM = (leptons[TAU].getIsospin()) - Qf * s02();
3831 } else if (f.is("UP")) {
3832 Qf = quarks[UP].getCharge();
3833 gfLSM = (quarks[UP].getIsospin()) - Qf * s02();
3834 } else if (f.is("CHARM")) {
3835 Qf = quarks[CHARM].getCharge();
3836 gfLSM = (quarks[CHARM].getIsospin()) - Qf * s02();
3837 } else if (f.is("DOWN")) {
3838 Qf = quarks[DOWN].getCharge();
3839 gfLSM = (quarks[DOWN].getIsospin()) - Qf * s02();
3840 } else if (f.is("STRANGE")) {
3841 Qf = quarks[STRANGE].getCharge();
3842 gfLSM = (quarks[STRANGE].getIsospin()) - Qf * s02();
3843 } else if (f.is("BOTTOM")) {
3844 Qf = quarks[BOTTOM].getCharge();
3845 gfLSM = (quarks[BOTTOM].getIsospin()) - Qf * s02();
3846 } else
3847 throw std::runtime_error("StandardModel::MLL2eeff: wrong argument");
3848
3849 // LL SM squared amplitude
3850 MLL2SM = Qf * Qf
3851 + (is2c2 * is2c2 * (geLSM * geLSM * gfLSM * gfLSM) * s * s
3852 + 2.0 * Qf * is2c2 * (geLSM * gfLSM) * Mz2s * s) / (Mz2s * Mz2s + Mz * Mz * GZ * GZ);
3853
3854 return MLL2SM;
3855
3856}

◆ MLR2eeff()

const double StandardModel::MLR2eeff ( const Particle  f,
const double  s 
) const

Definition at line 3702 of file StandardModel/src/StandardModel.cpp.

3702 {
3703
3704 // Definitions
3705 double Qf, geLSM, gfRSM, is2c2, GZ, Mz2s;
3706
3707 double MLR2SM;
3708
3709 // -------------------------------------------
3710
3711 geLSM = (leptons[ELECTRON].getIsospin()) - (leptons[ELECTRON].getCharge()) * s02();
3712
3713 is2c2 = 1. / s02() / c02();
3714
3715 GZ = Gamma_Z();
3716
3717 Mz2s = Mz * Mz - s;
3718
3719 if (f.is("ELECTRON")) {
3720 Qf = leptons[ELECTRON].getCharge();
3721 gfRSM = - Qf * s02();
3722 } else if (f.is("MU")) {
3723 Qf = leptons[MU].getCharge();
3724 gfRSM = - Qf * s02();
3725 } else if (f.is("TAU")) {
3726 Qf = leptons[TAU].getCharge();
3727 gfRSM = - Qf * s02();
3728 } else if (f.is("UP")) {
3729 Qf = quarks[UP].getCharge();
3730 gfRSM = - Qf * s02();
3731 } else if (f.is("CHARM")) {
3732 Qf = quarks[CHARM].getCharge();
3733 gfRSM = - Qf * s02();
3734 } else if (f.is("DOWN")) {
3735 Qf = quarks[DOWN].getCharge();
3736 gfRSM = - Qf * s02();
3737 } else if (f.is("STRANGE")) {
3738 Qf = quarks[STRANGE].getCharge();
3739 gfRSM = - Qf * s02();
3740 } else if (f.is("BOTTOM")) {
3741 Qf = quarks[BOTTOM].getCharge();
3742 gfRSM = - Qf * s02();
3743 } else
3744 throw std::runtime_error("StandardModel::MLR2eeff: wrong argument");
3745
3746 // LR, RL, LL and RR SM squared amplitudes
3747 MLR2SM = Qf * Qf
3748 + (is2c2 * is2c2 * (geLSM * geLSM * gfRSM * gfRSM) * s * s
3749 + 2.0 * Qf * is2c2 * (geLSM * gfRSM) * Mz2s * s) / (Mz2s * Mz2s + Mz * Mz * GZ * GZ);
3750
3751 return MLR2SM;
3752}

◆ MRL2eeff()

const double StandardModel::MRL2eeff ( const Particle  f,
const double  s 
) const

Definition at line 3753 of file StandardModel/src/StandardModel.cpp.

3753 {
3754
3755 // Definitions
3756 double Qf, geRSM, gfLSM, is2c2, GZ, Mz2s;
3757
3758 double MRL2SM;
3759
3760 // -------------------------------------------
3761
3762 geRSM = - (leptons[ELECTRON].getCharge()) * s02();
3763
3764 is2c2 = 1. / s02() / c02();
3765
3766 GZ = Gamma_Z();
3767
3768 Mz2s = Mz * Mz - s;
3769
3770 if (f.is("ELECTRON")) {
3771 Qf = leptons[ELECTRON].getCharge();
3772 gfLSM = (leptons[ELECTRON].getIsospin()) - Qf * s02();
3773 } else if (f.is("MU")) {
3774 Qf = leptons[MU].getCharge();
3775 gfLSM = (leptons[MU].getIsospin()) - Qf * s02();
3776 } else if (f.is("TAU")) {
3777 Qf = leptons[TAU].getCharge();
3778 gfLSM = (leptons[TAU].getIsospin()) - Qf * s02();
3779 } else if (f.is("UP")) {
3780 Qf = quarks[UP].getCharge();
3781 gfLSM = (quarks[UP].getIsospin()) - Qf * s02();
3782 } else if (f.is("CHARM")) {
3783 Qf = quarks[CHARM].getCharge();
3784 gfLSM = (quarks[CHARM].getIsospin()) - Qf * s02();
3785 } else if (f.is("DOWN")) {
3786 Qf = quarks[DOWN].getCharge();
3787 gfLSM = (quarks[DOWN].getIsospin()) - Qf * s02();
3788 } else if (f.is("STRANGE")) {
3789 Qf = quarks[STRANGE].getCharge();
3790 gfLSM = (quarks[STRANGE].getIsospin()) - Qf * s02();
3791 } else if (f.is("BOTTOM")) {
3792 Qf = quarks[BOTTOM].getCharge();
3793 gfLSM = (quarks[BOTTOM].getIsospin()) - Qf * s02();
3794 } else
3795 throw std::runtime_error("StandardModel::MRL2eeff: wrong argument");
3796
3797 // RL SM squared amplitude
3798 MRL2SM = Qf * Qf
3799 + (is2c2 * is2c2 * (geRSM * geRSM * gfLSM * gfLSM) * s * s
3800 + 2.0 * Qf * is2c2 * (geRSM * gfLSM) * Mz2s * s) / (Mz2s * Mz2s + Mz * Mz * GZ * GZ);
3801
3802 return MRL2SM;
3803}

◆ MRR2eeff()

const double StandardModel::MRR2eeff ( const Particle  f,
const double  s,
const double  t 
) const

Definition at line 3857 of file StandardModel/src/StandardModel.cpp.

3857 {
3858
3859 // Definitions
3860 double Qf, geRSM, gfRSM, is2c2, GZ, Mz2s;
3861
3862 double MRR2SM;
3863
3864 // -------------------------------------------
3865
3866 geRSM = - (leptons[ELECTRON].getCharge()) * s02();
3867
3868 is2c2 = 1. / s02() / c02();
3869
3870 GZ = Gamma_Z();
3871
3872 Mz2s = Mz * Mz - s;
3873
3874 if (f.is("ELECTRON")) {
3875 Qf = leptons[ELECTRON].getCharge();
3876 gfRSM = - Qf * s02();
3877 } else if (f.is("MU")) {
3878 Qf = leptons[MU].getCharge();
3879 gfRSM = - Qf * s02();
3880 } else if (f.is("TAU")) {
3881 Qf = leptons[TAU].getCharge();
3882 gfRSM = - Qf * s02();
3883 } else if (f.is("UP")) {
3884 Qf = quarks[UP].getCharge();
3885 gfRSM = - Qf * s02();
3886 } else if (f.is("CHARM")) {
3887 Qf = quarks[CHARM].getCharge();
3888 gfRSM = - Qf * s02();
3889 } else if (f.is("DOWN")) {
3890 Qf = quarks[DOWN].getCharge();
3891 gfRSM = - Qf * s02();
3892 } else if (f.is("STRANGE")) {
3893 Qf = quarks[STRANGE].getCharge();
3894 gfRSM = - Qf * s02();
3895 } else if (f.is("BOTTOM")) {
3896 Qf = quarks[BOTTOM].getCharge();
3897 gfRSM = - Qf * s02();
3898 } else
3899 throw std::runtime_error("StandardModel::MRR2eeff: wrong argument");
3900
3901 // RR SM squared amplitude
3902 MRR2SM = Qf * Qf
3903 + (is2c2 * is2c2 * (geRSM * geRSM * gfRSM * gfRSM) * s * s
3904 + 2.0 * Qf * is2c2 * (geRSM * gfRSM) * Mz2s * s) / (Mz2s * Mz2s + Mz * Mz * GZ * GZ);
3905
3906 return MRR2SM;
3907}

◆ Mw()

const double StandardModel::Mw ( ) const
virtual

The SM prediction for the \(W\)-boson mass in the on-shell scheme, \(M_{W,\mathrm{SM}}\).

When the model flag Mw of StandardModel is set to APPROXIMATEFORMULA, the current function uses the two-loop approximate formula in EWSMApproximateFormulae::Mw(), which includes the full two-loop EW contribution of \({\cal O}(\alpha^2)\) as well as the leading \({\cal O}(G_\mu^2\alpha_s m_t^4)\) and \({\cal O}(G_\mu^3m_t^6)\) contributions.

When the model flag Mw is not set to APPROXIMATEFORMULA, the \(W\)-boson mass is computed from \(\Delta r(M_W)\) with an iterative procedure. The target accuracy of the iterative calculation is specified with the constant Mw_error. This function calls resumMw(), in which \(M_W\) is computed with a given \(\Delta r\), equivalently with \(\Delta\rho\) and \(\Delta r_{\mathrm{rem}}\)

Returns
\(M_{W,\mathrm{SM}}\) in GeV
See also
resumMw()
Attention
If the model flag CacheInStandardModel of StandardModel is set to true, the caching method implemented in the current class is employed.

Reimplemented in GeorgiMachacek, NPbase, NPEpsilons, NPEpsilons_pureNP, NPSMEFTd6, NPSMEFTd6General, NPZbbbar, SUSY, and THDMW.

Definition at line 1018 of file StandardModel/src/StandardModel.cpp.

1019{
1020 /* Debug */
1021 //std::cout << std::boolalpha
1022 // << checkScheme(schemeMw_cache,schemeMw,false)
1023 // << " [cache:" << schemeMw_cache
1024 // << " current:" << schemeMw << "]" << std::endl;
1025
1026 if (FlagMWinput)
1027 return Mw_inp;
1028
1030 if (useMw_cache)
1031 return Mw_cache;
1032
1033 double Mw;
1034 if (FlagMw.compare("APPROXIMATEFORMULA") == 0)
1036 else {
1037 //std::cout << std::setprecision(12)
1038 // << "TEST: Mw_tree = " << Mw_tree() << std::endl;
1039
1040 double DeltaRho[orders_EW_size], DeltaR_rem[orders_EW_size];
1041 ComputeDeltaRho(Mw_tree(), DeltaRho);
1042 ComputeDeltaR_rem(Mw_tree(), DeltaR_rem);
1043 Mw = resumMw(Mw_tree(), DeltaRho, DeltaR_rem);
1044
1045 /* Mw from iterations */
1046 double Mw_org = Mw_tree();
1047 while (fabs(Mw - Mw_org) > Mw_error) {
1048 Mw_org = Mw;
1049 ComputeDeltaRho(Mw, DeltaRho);
1050 ComputeDeltaR_rem(Mw, DeltaR_rem);
1051 Mw = resumMw(Mw, DeltaRho, DeltaR_rem);
1052 /* TEST */
1053 //int prec_def = std::cout.precision();
1054 //std::cout << std::setprecision(12) << "TEST: Mw_org = " << Mw_org
1055 // << " Mw_new = " << Mw << std::endl;
1056 //std::cout.precision(prec_def);
1057 }
1058 }
1059
1060// Mw = 80.426; // FOR HEFFDF1 TEST: VALUE IN hep-ph/0512066
1061// Mw = 80.379; // FOR HEFFDF1 TEST: VALUE IN 2007.04191
1062 Mw_cache = Mw;
1063 useMw_cache = true;
1064 return Mw;
1065}
double Mw() const
The -boson mass with the full two-loop EW corrections.
static const double Mw_error
The target accuracy of the iterative calculation of the -boson mass in units of GeV.
void ComputeDeltaR_rem(const double Mw_i, double DeltaR_rem[orders_EW_size]) const
A method to collect computed via subclasses.
const double Mw_tree() const
The tree-level mass of the boson, .
double resumMw(const double Mw_i, const double DeltaRho[orders_EW_size], const double DeltaR_rem[orders_EW_size]) const
A method to compute the -boson mass from and .

◆ Mw_tree()

const double StandardModel::Mw_tree ( ) const

The tree-level mass of the \(W\) boson, \(M_W^{\mathrm{tree}}\).

Returns
\(M_W^{\mathrm{tree}}\) in GeV.

Definition at line 996 of file StandardModel/src/StandardModel.cpp.

997{
998 if (FlagMWinput){
999 return Mw_inp;
1000 } else
1001 return ( Mz / sqrt(2.0) * sqrt(1.0 + sqrt(1.0 - 4.0 * M_PI * ale / sqrt(2.0) / GF / Mz / Mz)));
1002}

◆ MwbarFromMw()

const double StandardModel::MwbarFromMw ( const double  Mw) const

A method to convert the \(W\)-boson mass in the experimental/running-width scheme to that in the complex-pole/fixed-width scheme.

The mass parameter \(\overline{M}_W\) in the complex-pole/fixed-width scheme [Bardin:1988xt] is given by

\[ \overline{M}_{W} = M_{W} - \frac{\Gamma_{W}^2}{2M_{W}}\,, \]

where \(M_W\) and \(\Gamma_{W}\) are the mass and width of the \(W\) boson in the experimental/running-width scheme:

\[ \Gamma_W = \frac{3G_\mu M_W^3}{2\sqrt{2}\pi} \left( 1 + \frac{2\alpha_s(M_W^2)}{3\pi} \right)\,. \]

Parameters
[in]Mwthe \(W\)-boson mass in the experimental/running-width scheme
Returns
\(\overline{M}_W\) in GeV

Definition at line 1203 of file StandardModel/src/StandardModel.cpp.

1204{
1205 double AlsMw = Als(Mw, FULLNLO);
1206 double Gw_SM = 3.0 * GF * pow(Mw, 3.0) / 2.0 / sqrt(2.0) / M_PI
1207 * (1.0 + 2.0 * AlsMw / 3.0 / M_PI);
1208
1209 return ( Mw - Gw_SM * Gw_SM / 2.0 / Mw);
1210}

◆ MwFromMwbar()

const double StandardModel::MwFromMwbar ( const double  Mwbar) const

A method to convert the \(W\)-boson mass in the complex-pole/fixed-width scheme to that in the experimental/running-width scheme.

The experimental mass \(M_W\) is derived

\[ M_W = \overline{M}_W + \frac{\Gamma_{W}^2}{2\overline{M}_{W}}\,, \]

where \(\overline{M}_W\) is the mass parameter in the complex-pole/fixed-width scheme [Bardin:1988xt], and \(\Gamma_{W}\) is the \(W\)-boson width in the experimental/running-width scheme:

\[ \Gamma_W = \frac{3G_\mu M_W^3}{2\sqrt{2}\pi} \left( 1 + \frac{2\alpha_s(M_W^2)}{3\pi} \right) \approx \frac{3G_\mu \overline{M}_W^3}{2\sqrt{2}\pi} \left( 1 + \frac{2\alpha_s(\overline{M}_W^2)}{3\pi} \right)\,. \]

Parameters
[in]Mwbarthe \(W\)-boson mass in the complex-pole/fixed-width scheme
Returns
\(M_W\) in GeV

Definition at line 1212 of file StandardModel/src/StandardModel.cpp.

1213{
1214 double AlsMw = Als(Mwbar, FULLNNLO);
1215 double Gw_SM = 3.0 * GF * pow(Mwbar, 3.0) / 2.0 / sqrt(2.0) / M_PI
1216 * (1.0 + 2.0 * AlsMw / 3.0 / M_PI);
1217
1218 return (Mwbar + Gw_SM * Gw_SM / 2.0 / Mwbar);
1219}

◆ Mzbar()

double StandardModel::Mzbar ( ) const

The \(Z\)-boson mass \(\overline{M}_Z\) in the complex-pole/fixed-width scheme.

The mass parameter \(\overline{M}_Z\) in the complex-pole/fixed-width scheme [Bardin:1988xt] is given by

\[ \overline{M}_{Z} = M_{Z} - \frac{\Gamma_{Z}^2}{2M_{Z}}\,, \]

where \(M_Z\) and \(\Gamma_{Z}\) are the mass and width of the \(Z\) boson in the experimental/running-width scheme:

\begin{align} \Gamma(Z\to f\bar{f}) = \frac{G_\mu M_Z^3}{24\sqrt{2}\pi} \left[ \left( \frac{v_f}{a_f} \right)^2 + 1 \right] \times \left\{ \begin{array}{ll} 1 & \mathrm{for}\quad f=\ell\,, \\[2mm] \displaystyle N_c \left( 1 + \frac{\alpha_s(M_Z^2)}{\pi} \right) & \mathrm{for}\quad f=q \end{array} \right. \end{align}

with \(v_f/a_f=1-4|Q_f|s_{W,\mathrm{tree}}^2\).

Returns
\(\overline{M}_Z\) in GeV

Definition at line 1186 of file StandardModel/src/StandardModel.cpp.

1187{
1188 double G0 = GF * pow(Mz, 3.0) / 24.0 / sqrt(2.0) / M_PI;
1189 double sW2tree = 1.0 - Mw_tree() * Mw_tree() / Mz / Mz;
1190 double Gz = 6.0 * G0; // neutrinos
1191 Gz += 3.0 * G0 * (pow(1.0 - 4.0 * sW2tree, 2.0) + 1.0); // e, mu and tau
1192 Gz += 6.0 * G0 * (pow(1.0 - 8.0 / 3.0 * sW2tree, 2.0) + 1.0)
1193 * (1.0 + AlsMz / M_PI); // u and c
1194 Gz += 9.0 * G0 * (pow(1.0 - 4.0 / 3.0 * sW2tree, 2.0) + 1.0)
1195 * (1.0 + AlsMz / M_PI); // d, s and b
1196
1197 //Gz = 2.4952; // experimental data
1198 //std::cout << "Gz=" << Gz << std::endl; // for test
1199
1200 return ( Mz - Gz * Gz / 2.0 / Mz);
1201}

◆ N_nu()

const double StandardModel::N_nu ( ) const
virtual

The number of neutrinos obtained indirectly from the measurements at the Z pole, \(N_{\nu}\).

\(N_{\nu}\) is calculated with

\[ N_{\nu} = \frac{\Gamma_\ell}{\Gamma_{\nu}}\left(\sqrt{\frac{12\pi R_\ell}{M_Z^2 \sigma_\mathrm{had}^0}}-R_\ell - 3\right)\,. \]

Returns
\(N_{\nu} \)

Reimplemented in NPbase.

Definition at line 1555 of file StandardModel/src/StandardModel.cpp.

1556{
1557 double Nnu = 0.0;
1558 double Gl = 0.0;
1559 double Rl = 0.0;
1560
1561 // Don't assume lepton universality: average over lepton flavours
1563 Rl = (1.0/3.0) * ( R0_f(leptons[ELECTRON]) + R0_f(leptons[MU]) + R0_f(leptons[TAU]) );
1564
1565 Nnu = sqrt( 12.0 * M_PI * Rl / Mz / Mz / sigma0_had() ) - Rl -3.0;
1566
1567 Nnu = (Gl/Gamma_inv()) * Nnu;
1568
1569 return Nnu;
1570
1571}
virtual const double sigma0_had() const
The hadronic cross section for at the -pole, .
virtual const double R0_f(const Particle f) const
The ratio .

◆ PostUpdate()

bool StandardModel::PostUpdate ( )
virtual

The post-update method for StandardModel.

This method runs all the procedures that are need to be executed after the model is successfully updated. This includes

  • computing the updated CKM and PMNS matrices
  • computing the Yukawa matrices
  • updating the Standard Model parameters in the StandardModelMatching class.
    Returns
    a boolean that is true if the execution is successful

Reimplemented from QCD.

Reimplemented in FlavourWilsonCoefficient, FlavourWilsonCoefficient_DF2, LoopMediators, RealWeakEFTCC, RealWeakEFTLFV, GeneralSUSY, GeorgiMachacek, LeftRightSymmetricModel, MFV, HiggsChiral, HiggsKigen, NPEpsilons, NPSMEFTd6, NPSMEFTd6General, NPSMEFTd6U2, NPSMEFTd6U2qU1le, NPSMEFTd6U3, NPZbbbar, NPZbbbarLinearized, pMSSM, SUSY, SUSYMassInsertion, THDM, and THDMW.

Definition at line 241 of file StandardModel/src/StandardModel.cpp.

242{
243 if (!QCD::PostUpdate()) return (false);
244
245 /* Set the CKM and PMNS matrices if not already set in the derived classes */
246 if(requireCKM)
247 computeCKM();
248
249 /* Compute the 5-quark contribution to the running of alpha*/
250 dAl5hMz = Dalpha5hMz();
251
252 /* Set the Yukawa matrices */
253 if (!isModelSUSY()) {
255 }
256
257 /* Check whether the parameters for the EWPO are updated or not */
258 if (!checkSMparamsForEWPO()) {
260 useDeltaAlpha_cache = false;
261 useMw_cache = false;
262 useGammaW_cache = false;
263 for (int i = 0; i < 12; ++i) {
264 useRhoZ_f_cache[i] = false;
265 useKappaZ_f_cache[i] = false;
266 }
267 }
269 /* Necessary for updating StandardModel parameters in StandardModelMatching */
270 if (!isModelSUSY()) SMM.getObj().updateSMParameters();
271
272 iterationNo++;
273
274 return (true);
275}
void setSMupdated() const
a member used for the caching for .
Definition: Flavour.cpp:351
bool isModelSUSY() const
Definition: Model.h:182
virtual bool PostUpdate()
The post-update method for QCD.
Definition: QCD.cpp:158
virtual void computeCKM()
The method to compute the CKM matrix.
virtual void computeYukawas()
The method to compute the Yukawas matrix.
virtual const double Dalpha5hMz() const
The 5-quark contribution to the running of the em constant to the pole. .
bool checkSMparamsForEWPO()
A method to check whether the parameters relevant to the EWPO are updated.

◆ PreUpdate()

bool StandardModel::PreUpdate ( )
virtual

The pre-update method for StandardModel.

This method initializes the internal flags requireCKM, requireYe and requireYn, and calls QCD::PreUpdate(), before updating the model parameters with the method Update().

Returns
a boolean that is true if the execution is successful

Reimplemented from QCD.

Reimplemented in FlavourWilsonCoefficient, LoopMediators, RealWeakEFTCC, RealWeakEFTLFV, GeneralSUSY, GeorgiMachacek, LeftRightSymmetricModel, MFV, NPSMEFTd6General, pMSSM, SUSY, SUSYMassInsertion, THDM, and THDMW.

Definition at line 214 of file StandardModel/src/StandardModel.cpp.

215{
216 requireCKM = false;
217 requireYe = false;
218 requireYn = false;
219
220 if (!QCD::PreUpdate()) return (false);
221
222 return (true);
223}
virtual bool PreUpdate()
The pre-update method for QCD.
Definition: QCD.cpp:130

◆ Qwemoller()

const double StandardModel::Qwemoller ( const double  q2,
const double  y 
) const
virtual

The computation of the electron's weak charge.

Parameters
[in]q2the \(Q^2\) at which the weak charge is measured
[in]y
Returns
\(Q_{w}(e)\)

Reimplemented in NPbase.

Definition at line 2664 of file StandardModel/src/StandardModel.cpp.

2665{
2666 // Weak charge
2667 double Qwe;
2668
2669 // definitions
2670 double MwSM,f1,fy,f2,af2;
2671 const double mpion=134.9766e-3;
2672
2673 // -----------------------------------------------------------------
2674
2675 double dalfos, dalfms, alfams;
2676 double rhoNC, kappa0, s2MSbar,c2MSbar;
2677 double xi;
2678 double leptk0,quarkk0;
2679 double elm=leptons[ELECTRON].getMass(), mum=leptons[MU].getMass(), taum=leptons[TAU].getMass();
2680
2681 // -----------------------------------------------------------------
2682
2683 // w mass
2684 MwSM=Mw();
2685
2686 // xi factor
2687 xi=mHl*mHl/Mz/Mz;
2688
2689 // -----------------------------------------------------------------
2690
2691 // universal corrections
2692 // ---------------------
2693
2694 // obtaining alfa(mz)_msbar from alfa(mz)_on-shell
2695 // -----------------------------------------------
2696
2697 // on-shell value of delta alpha(mz)
2698 dalfos=1.0-ale/alphaMz();
2699 // msbar value of delta alpha(mz) (formula from PDG, Erler & Langacker ew review)
2700 dalfms=dalfos+ale/M_PI*(100.0/27.0-1.0/6.0-7.0*2.0*log(Mz/MwSM)/4.0);
2701 // msbar value of alfa(mz)
2702 alfams=ale/(1.0-dalfms);
2703
2704 // ms bar weinberg's angle from the effective leptonic angle
2705 // (formula from PDG, Erler & Langacker ew review)
2706 // ---------------------------------------------------------
2707 s2MSbar=(myApproximateFormulae->sin2thetaEff_l_full())-0.00029;
2708 c2MSbar=1.0-s2MSbar;
2709
2710 // rho parameter (expansion in alfams)
2711 // -------------
2712
2713 rhoNC=1.0+alfams/(4.0*M_PI)*(3.0/(4.0*s2MSbar*s2MSbar)*log(c2MSbar)-7.0/(4.0*s2MSbar)+3.0*mtpole*mtpole/(4.0*s2MSbar*MwSM*MwSM) + 3.0*xi/(4.0*s2MSbar)*(log(c2MSbar/xi)/(c2MSbar-xi)+(1.0/c2MSbar)*log(xi)/(1.0-xi)));
2714
2715 // kappa at zero momentum (expansion in alfa)
2716 // ----------------------
2717
2718 // lepton contribution to kappa0
2719 leptk0=((-0.5)*(-1)-2.0*s2MSbar)*2.0*(log(elm/Mz)+log(mum/Mz)+log(taum/Mz))/3.0;
2720
2721 // quark contribution to kappa0 (updated from hep-ph/0302149)
2722 quarkk0=-6.802;
2723
2724 kappa0=1.0-ale/(2.0*M_PI*s2MSbar)*(leptk0+quarkk0-(7.0*c2MSbar/2.0+1.0/12.0)*log(c2MSbar)+(7.0/9.0-s2MSbar/3.0));
2725
2726 // -----------------------------------------------------------------
2727
2728 // f1(y,q2) (expansion in alfa)
2729 // --------
2730
2731 // f(y)
2732 fy=-2.0*log(y*(1.0-y))/3.0+1.0/pow((1.0-y+y*y),2)*(-2.0*(1.0-y)*(3.0-3.0*y+4.0*y*y*y- 3.0*y*y*y*y)*log(1.0-y)-2.0*y*(1.0+3.0*y-6.0*y*y+8.0*y*y*y-3.0*y*y*y*y)*log(y)+ (1.0-y)*(2.0-2.0*y-7.0*y*y+10.0*y*y*y-8.0*y*y*y*y+3.0*y*y*y*y*y)*log(1.0-y)*log(1.0-y)- y*(2.0-3.0*y-5.0*y*y+8.0*y*y*y-7.0*y*y*y*y+3.0*y*y*y*y*y)*log(y)*log(y)+ (2.0-4.0*y+11.0*y*y*y-13.0*y*y*y*y+9.0*y*y*y*y*y-3.0*y*y*y*y*y*y)*(M_PI*M_PI-2.0*log(1.0-y)*log(y)));
2733
2734 f1=-ale/(4.0*M_PI)*(1.0-4.0*kappa0*s2MSbar)*(22.0*log(y*Mz*Mz/q2)/3.0+85.0/9.0+fy);
2735
2736 // note that i have used 1-4*kappa*s2MSbar instead of 1-4*s2MSbar or an average as suggested in the
2737 // reference
2738
2739
2740 // f2(y,q2) (expansion in alfa)
2741 // --------
2742 // (y=1/2 approximattion using a pion loop calculation)
2743
2744 // af2
2745 af2=sqrt(1.0+4.0*mpion*mpion/q2);
2746 f2=ale/(4.0*M_PI)*(af2*af2*af2/3.0*log((af2+1.0)/(af2-1.0))-2.0/9.0-2.0*af2*af2/3.0);
2747
2748
2749 // electron's weak charge
2750 // ----------------------
2751 Qwe=-rhoNC*(1.0-4.0*kappa0*s2MSbar+alfams/(4.0*M_PI*s2MSbar)+f1+f2- 3.0*alfams*(1.0-4.0*kappa0*s2MSbar)*(1.0+(1.0-4.0*kappa0*s2MSbar)*(1.0-4.0*kappa0*s2MSbar))/(32.0*M_PI*s2MSbar*c2MSbar));
2752
2753 // again, i have used 1-4*kappa*s2MSbar even in the loop contributions
2754
2755 return Qwe;
2756}
A class for , relevant for mesons mixing in the Standard Model.
Definition: xi.h:23

◆ Qwn()

const double StandardModel::Qwn ( ) const
virtual

The computation of the neutron weak charge: Qwn.

Follows J.Erler,A.Kurylov,M.J.Ramsey-Musolf hep-ph/0302149.

Returns
\(Q_{W}(n)\)

Reimplemented in NPbase.

Definition at line 2888 of file StandardModel/src/StandardModel.cpp.

2889{
2890 // Definitions
2891 double qwneutron;
2892
2893 double MwSM,alfapi,asMw,dkappa5h,s2MSbar0,deltae,deltaep,boxnww,boxnzz,boxnaz;
2894 // I choose as lambda m_rho (pdg rho(770)) --> caz=3/2
2895 const double lambda=775.49e-3;
2896 const double caz=1.5;
2897
2898 // lepton masses
2899 double mlept[3]={leptons[ELECTRON].getMass(),leptons[MU].getMass(),leptons[TAU].getMass()};
2900
2901 // -----------------------------------------------------------------
2902 double dalfos, dalfms, alfams;
2903 double rhoNC, s2MSbar,c2MSbar;
2904 double xi;
2905 double elm=leptons[ELECTRON].getMass();
2906 // -----------------------------------------------------------------
2907
2908 // W mass
2909 MwSM=Mw();
2910
2911 // xi factor
2912 xi=mHl*mHl/Mz/Mz;
2913
2914 // alfa/pi
2915 alfapi=ale/M_PI;
2916
2917 // alfa_s(Mw)
2918 asMw = Als(MwSM, FULLNLO);
2919
2920 // -----------------------------------------------------------------
2921
2922 // Universal corrections
2923 // ---------------------
2924
2925 // Obtaining alfa(mz)_msbar from alfa(mz)_on-shell
2926 // -----------------------------------------------
2927
2928 // on-shell value of delta alpha(mz)
2929 dalfos=1.0-ale/alphaMz();
2930 // MSbar value of delta alpha(mz) (formula from PDG, Erler & Langacker ew review)
2931 dalfms=dalfos+ale/M_PI*(100.0/27.0-1.0/6.0-7.0*2.0*log(Mz/MwSM)/4.0);
2932 // MSbar value of alfa(mz)
2933 alfams=ale/(1.0-dalfms);
2934
2935 // MS bar weinberg's angle from the effective leptonic angle
2936 // (formula from PDG, Erler & Langacker ew review)
2937 // ---------------------------------------------------------
2938 s2MSbar=(myApproximateFormulae->sin2thetaEff_l_full())-0.00029;
2939 c2MSbar=1.0-s2MSbar;
2940
2941 // rho parameter (expansion in alfams)
2942 // -------------
2943
2944 rhoNC=1.0+alfams/(4.0*M_PI)*(3.0/(4.0*s2MSbar*s2MSbar)*log(c2MSbar)-7.0/(4.0*s2MSbar)+3.0*mtpole*mtpole/(4.0*s2MSbar*MwSM*MwSM) + 3.0*xi/(4.0*s2MSbar)*(log(c2MSbar/xi)/(c2MSbar-xi)+(1.0/c2MSbar)*log(xi)/(1.0-xi)));
2945
2946 // -----------------------------------------------------------------
2947
2948 // sin2w_ms(0) eq.14
2949 // -----------------
2950
2951 // hadronic contribution
2952 dkappa5h=7.9e-3;
2953
2954 s2MSbar0=0.0;
2955
2956 for (int i = 0; i < 3; ++i) {
2957 s2MSbar0=s2MSbar0+2.0*log(Mz/mlept[i]);
2958 }
2959
2960 s2MSbar0=s2MSbar+dkappa5h+alfapi*((s2MSbar0*(1.0+0.75*alfapi)+135.0*alfapi/32.0)*(1.0-4.0*s2MSbar)/12.0- (7.0*c2MSbar/4.0+1.0/24.0)*2.0*log(Mz/MwSM)+s2MSbar/6.0-7.0/18.0);
2961
2962 // -----------------------------------------------------------------
2963
2964 // external leg corrections
2965
2966 deltae=-0.5*alfapi;
2967
2968 deltaep=-alfapi/3.0*(1.0-4.0*s2MSbar)*(2.0*log(Mz/elm)+1.0/6.0);
2969
2970 // -----------------------------------------------------------------
2971
2972 // boxes
2973 // -----
2974
2975 boxnww=alfams*(-2.0+4.0*(1.0-asMw/M_PI))/(4.0*M_PI*s2MSbar);
2976
2977 // pure zz and az boxes from prd 17 3055 app.a
2978
2979 boxnzz=alfams*(9.0/4.0-13.0*s2MSbar+34.0*s2MSbar*s2MSbar-32.0*s2MSbar*s2MSbar*s2MSbar)*(1.0-AlsMz/M_PI)/(4.0*M_PI*s2MSbar*c2MSbar);
2980
2981 // i assumme the same caz as in the proton enters for the neutron
2982 boxnaz=alfams*(4.0-16.0*s2MSbar)*(2.0*log(Mz/lambda)+caz)/(2.0*M_PI);
2983
2984 // -----------------------------------------------------------------
2985
2986 // weak charges
2987 // ------------
2988
2989 qwneutron=-(rhoNC+deltae)*(1.0+deltaep)+boxnww+boxnzz+boxnaz;
2990
2991 return qwneutron;
2992
2993}

◆ Qwp()

const double StandardModel::Qwp ( ) const
virtual

The computation of the proton weak charge: Qwp.

Follows J.Erler,A.Kurylov,M.J.Ramsey-Musolf hep-ph/0302149.

Returns
\(Q_{W}(p)\)

Reimplemented in NPbase.

Definition at line 2780 of file StandardModel/src/StandardModel.cpp.

2781{
2782 // Definitions
2783 double qwproton;
2784
2785 double MwSM,alfapi,asMw,dkappa5h,s2MSbar0,deltae,deltaep,boxpww,boxpzz,boxpaz;
2786 // I choose as lambda m_rho (pdg rho(770)) --> caz=3/2
2787 const double lambda=775.49e-3;
2788 const double caz=1.5;
2789
2790 // lepton masses
2791 double mlept[3]={leptons[ELECTRON].getMass(),leptons[MU].getMass(),leptons[TAU].getMass()};
2792
2793 // -----------------------------------------------------------------
2794 double dalfos, dalfms, alfams;
2795 double rhoNC, s2MSbar,c2MSbar;
2796 double xi;
2797 double elm=leptons[ELECTRON].getMass();
2798 // -----------------------------------------------------------------
2799
2800 // W mass
2801 MwSM=Mw();
2802
2803 // xi factor
2804 xi=mHl*mHl/Mz/Mz;
2805
2806 // alfa/pi
2807 alfapi=ale/M_PI;
2808
2809 // alfa_s(Mw)
2810 asMw = Als(MwSM, FULLNLO);
2811
2812 // -----------------------------------------------------------------
2813
2814 // Universal corrections
2815 // ---------------------
2816
2817 // Obtaining alfa(mz)_msbar from alfa(mz)_on-shell
2818 // -----------------------------------------------
2819
2820 // on-shell value of delta alpha(mz)
2821 dalfos=1.0-ale/alphaMz();
2822 // MSbar value of delta alpha(mz) (formula from PDG, Erler & Langacker ew review)
2823 dalfms=dalfos+ale/M_PI*(100.0/27.0-1.0/6.0-7.0*2.0*log(Mz/MwSM)/4.0);
2824 // MSbar value of alfa(mz)
2825 alfams=ale/(1.0-dalfms);
2826
2827 // MS bar weinberg's angle from the effective leptonic angle
2828 // (formula from PDG, Erler & Langacker ew review)
2829 // ---------------------------------------------------------
2830 s2MSbar=(myApproximateFormulae->sin2thetaEff_l_full())-0.00029;
2831 c2MSbar=1.0-s2MSbar;
2832
2833 // rho parameter (expansion in alfams)
2834 // -------------
2835
2836 rhoNC=1.0+alfams/(4.0*M_PI)*(3.0/(4.0*s2MSbar*s2MSbar)*log(c2MSbar)-7.0/(4.0*s2MSbar)+3.0*mtpole*mtpole/(4.0*s2MSbar*MwSM*MwSM) + 3.0*xi/(4.0*s2MSbar)*(log(c2MSbar/xi)/(c2MSbar-xi)+(1.0/c2MSbar)*log(xi)/(1.0-xi)));
2837
2838 // -----------------------------------------------------------------
2839
2840 // sin2w_ms(0) eq.14
2841 // -----------------
2842
2843 // hadronic contribution
2844 dkappa5h=7.9e-3;
2845
2846 s2MSbar0=0.0;
2847
2848 for (int i = 0; i < 3; ++i) {
2849 s2MSbar0=s2MSbar0+2.0*log(Mz/mlept[i]);
2850 }
2851
2852 s2MSbar0=s2MSbar+dkappa5h+alfapi*((s2MSbar0*(1.0+0.75*alfapi)+135.0*alfapi/32.0)*(1.0-4.0*s2MSbar)/12.0- (7.0*c2MSbar/4.0+1.0/24.0)*2.0*log(Mz/MwSM)+s2MSbar/6.0-7.0/18.0);
2853
2854 // -----------------------------------------------------------------
2855
2856 // external leg corrections
2857
2858 deltae=-0.5*alfapi;
2859
2860 deltaep=-alfapi/3.0*(1.0-4.0*s2MSbar)*(2.0*log(Mz/elm)+1.0/6.0);
2861
2862 // -----------------------------------------------------------------
2863
2864 // boxes
2865 // -----
2866
2867 boxpww=alfams*(2.0+5.0*(1.0-asMw/M_PI))/(4.0*M_PI*s2MSbar);
2868
2869 // pure zz and az boxes from prd 17 3055 app.a
2870
2871 boxpzz=alfams*(9.0/4.0-14.0*s2MSbar+38.0*s2MSbar*s2MSbar-40.0*s2MSbar*s2MSbar*s2MSbar)*(1.0-AlsMz/M_PI)/(4.0*M_PI*s2MSbar*c2MSbar);
2872
2873 boxpaz=5.0*alfams*(1.0-4.0*s2MSbar)*(2.0*log(Mz/lambda)+caz)/(2.0*M_PI);
2874
2875 // i assumme the same caz as in the proton enters for the neutron
2876 // -----------------------------------------------------------------
2877
2878 // weak charges
2879 // ------------
2880
2881 qwproton=(rhoNC+deltae)*(1.0-4.0*s2MSbar0+deltaep)+boxpww+boxpzz+boxpaz;
2882
2883 return qwproton;
2884
2885}

◆ R0_f()

const double StandardModel::R0_f ( const Particle  f) const
virtual

The ratio \(R_\ell^0=\Gamma(Z\to {\rm hadrons})/\Gamma(Z\to \ell^+ \ell^-)\).

When checkNPZff_linearized() returns true and the model flag NoApproximateGammaZ of StandardModel is set to false, this function uses the two-loop approximate formula of \(R_\ell^0\) via EWSMApproximateFormulae::X_full_2_loop(). Otherwise, \(R_\ell^0\) is calculated with

\[ R_\ell^0 = \frac{\Gamma_h}{\Gamma_\ell}\,. \]

, where \(\ell\) denotes a charged lepton.

Parameters
[in]fa lepton or quark
Returns
\(R_\ell^0 \)

Reimplemented in NPbase, NPSMEFTd6General, NPZbbbar, and NPEpsilons.

Definition at line 1478 of file StandardModel/src/StandardModel.cpp.

1479{
1480
1481 if (f.is("ELECTRON")) {
1483 /* SM contribution with the approximate formula */
1484 return (myApproximateFormulae->X_full("R0_electron"));
1485 else
1486 return (Gamma_had() / GammaZ(leptons[ELECTRON]));
1487 } else if (f.is("MU")) {
1489 /* SM contribution with the approximate formula */
1490 return (myApproximateFormulae->X_full("R0_muon"));
1491 else
1492 return (Gamma_had() / GammaZ(leptons[MU]));
1493 } else if (f.is("TAU")) {
1495 /* SM contribution with the approximate formula */
1496 return (myApproximateFormulae->X_full("R0_tau"));
1497 else
1498 return (Gamma_had() / GammaZ(leptons[TAU]));
1499 } else if (f.is("NEUTRINO_1")) {
1501 /* SM contribution with the approximate formula */
1502 return (myApproximateFormulae->X_full("R0_neutrino"));
1503 else
1504 return (GammaZ(leptons[NEUTRINO_1]) / Gamma_had());
1505 } else if (f.is("NEUTRINO_2")) {
1507 /* SM contribution with the approximate formula */
1508 return (myApproximateFormulae->X_full("R0_neutrino"));
1509 else
1510 return (GammaZ(leptons[NEUTRINO_2]) / Gamma_had());
1511 } else if (f.is("NEUTRINO_3")) {
1513 /* SM contribution with the approximate formula */
1514 return (myApproximateFormulae->X_full("R0_neutrino"));
1515 else
1516 return (GammaZ(leptons[NEUTRINO_3]) / Gamma_had());
1517 } else if (f.is("UP")) {
1519 /* SM contribution with the approximate formula */
1520 return (myApproximateFormulae->X_full("R0_up"));
1521 else
1522 return (GammaZ(quarks[UP]) / Gamma_had());
1523
1524 } else if (f.is("STRANGE")) {
1526 /* SM contribution with the approximate formula */
1527 return (myApproximateFormulae->X_full("R0_strange"));
1528 else
1529 return (GammaZ(quarks[STRANGE]) / Gamma_had());
1530
1531 } else if (f.is("CHARM")) {
1533 /* SM contribution with the approximate formula */
1534 return (myApproximateFormulae->X_full("R0_charm"));
1535 else
1536 return (GammaZ(quarks[CHARM]) / Gamma_had());
1537
1538 } else if (f.is("BOTTOM")) {
1540 /* SM contribution with the approximate formula */
1541 return (myApproximateFormulae->X_full("R0_bottom"));
1542 else
1543 return (GammaZ(quarks[BOTTOM]) / Gamma_had());
1544
1545 } else throw std::runtime_error("StandardModel::R0_f called with wrong argument");
1546
1547}

◆ R_inv()

const double StandardModel::R_inv ( ) const
virtual

The ratio of the invisible and leptonic (electron) decay widths of the \(Z\) boson, \(R_{inv}\).

\(R_{inv}\) is calculated with

\[ R_{inv} = \frac{\Gamma_{inv}}{\Gamma_e}\,. \]

,

Returns
\(R_{inv} \)

Reimplemented in NPbase.

Definition at line 1549 of file StandardModel/src/StandardModel.cpp.

1550{
1551 return (Gamma_inv() / GammaZ(leptons[ELECTRON]));
1552
1553}

◆ RAq()

double StandardModel::RAq ( const QCD::quark  q) const
protected

The radiator factor associated with the final-state QED and QCD corrections to the the axial-vector-current interactions, \(R_A^q(M_Z^2)\).

See [Chetyrkin:1994js], [Bardin:1999ak], [Bardin:1999yd], [Baikov:2012er] and references therein.

Parameters
[in]qname of a quark (see QCD::quark)
Returns
\(R_A^q(M_Z^2)\)

Definition at line 2270 of file StandardModel/src/StandardModel.cpp.

2271{
2272 if (q == QCD::TOP) return 0.0;
2273
2274 double mcMz, mbMz;
2277 //mcMz = 0.56381685; /* for debug */
2278 //mbMz = 2.8194352; /* for debug */
2279
2280 double MtPole = mtpole;
2281
2282 /* z-component of isospin */
2283 double I3q = quarks[q].getIsospin();
2284 /* electric charge squared */
2285 double Qf2 = pow(quarks[q].getCharge(), 2.0);
2286
2287 /* s = Mz^2 */
2288 double s = Mz * Mz;
2289
2290 /* products of the charm and bottom masses at Mz */
2291 double mcMz2 = mcMz*mcMz;
2292 double mbMz2 = mbMz*mbMz;
2293 double mqMz2, mqdash4;
2294 switch (q) {
2295 case QCD::CHARM:
2296 mqMz2 = mcMz*mcMz;
2297 mqdash4 = mbMz2*mbMz2;
2298 break;
2299 case QCD::BOTTOM:
2300 mqMz2 = mbMz*mbMz;
2301 mqdash4 = mcMz2*mcMz2;
2302 break;
2303 default:
2304 mqMz2 = 0.0;
2305 mqdash4 = 0.0;
2306 break;
2307 }
2308
2309 /* Logarithms */
2310 //double log_t = log(pow(quarks[TOP].getMass(),2.0)/s);
2311 double log_t = log(MtPole * MtPole / s); // the pole mass
2312 double log_c = log(mcMz2 / s);
2313 double log_b = log(mbMz2 / s);
2314 double log_q;
2315 switch (q) {
2316 case QCD::CHARM:
2317 case QCD::BOTTOM:
2318 log_q = log(mqMz2 / s);
2319 break;
2320 default:
2321 log_q = 0.0;
2322 break;
2323 }
2324
2325 /* the active number of flavour */
2326 double nf = 5.0;
2327
2328 /* zeta functions */
2329 double zeta2 = getMyEWSMcache()->getZeta2();
2330 double zeta3 = getMyEWSMcache()->getZeta3();
2331 double zeta4 = getMyEWSMcache()->getZeta4();
2332 double zeta5 = getMyEWSMcache()->getZeta5();
2333
2334 /* massless non-singlet corrections */
2335 double C02 = 365.0 / 24.0 - 11.0 * zeta3 + (-11.0 / 12.0 + 2.0 / 3.0 * zeta3) * nf;
2336 double C03 = 87029.0 / 288.0 - 121.0 / 8.0 * zeta2 - 1103.0 / 4.0 * zeta3
2337 + 275.0 / 6.0 * zeta5
2338 + (-7847.0 / 216.0 + 11.0 / 6.0 * zeta2 + 262.0 / 9.0 * zeta3
2339 - 25.0 / 9.0 * zeta5) * nf
2340 + (151.0 / 162.0 - zeta2 / 18.0 - 19.0 / 27.0 * zeta3) * nf*nf;
2341 double C04 = -156.61 + 18.77 * nf - 0.7974 * nf * nf + 0.0215 * nf * nf*nf;
2342 //std::cout << "TEST: C02 = " << C02 << std::endl;// TEST (should be 1.40923)
2343 //std::cout << "TEST: C03 = " << C03 << std::endl;// TEST (should be -12.7671)
2344 //std::cout << "TEST: C04 = " << C04 << std::endl;// TEST (should be -80.0075)
2345
2346 /* quadratic massive corrections */
2347 double C23 = -80.0 + 60.0 * zeta3 + (32.0 / 9.0 - 8.0 / 3.0 * zeta3) * nf;
2348 double C20A = -6.0;
2349 double C21A = -22.0;
2350 double C22A = -8221.0 / 24.0 + 57.0 * zeta2 + 117.0 * zeta3
2351 + (151.0 / 12.0 - 2.0 * zeta2 - 4.0 * zeta3) * nf;
2352 double C23A = -4544045.0 / 864.0 + 1340.0 * zeta2 + 118915.0 / 36.0 * zeta3
2353 - 127.0 * zeta5
2354 + (71621.0 / 162.0 - 209.0 / 2.0 * zeta2 - 216.0 * zeta3
2355 + 5.0 * zeta4 + 55.0 * zeta5) * nf
2356 + (-13171.0 / 1944.0 + 16.0 / 9.0 * zeta2 + 26.0 / 9.0 * zeta3) * nf*nf;
2357
2358 /* quartic massive corrections */
2359 double C42 = 13.0 / 3.0 - 4.0 * zeta3;
2360 double C40A = 6.0;
2361 double C41A = 10.0;
2362 double C42A = 3389.0 / 12.0 - 162.0 * zeta2 - 220.0 * zeta3
2363 + (-41.0 / 6.0 + 4.0 * zeta2 + 16.0 / 3.0 * zeta3) * nf;
2364 double C42AL = 77.0 / 2.0 - 7.0 / 3.0 * nf;
2365
2366 /* power suppressed top-mass correction */
2367 //double xt = s/pow(quarks[TOP].getMass(),2.0);
2368 double xt = s / MtPole / MtPole; // the pole mass
2369 double C2t = xt * (44.0 / 675.0 - 2.0 / 135.0 * (-log_t));
2370
2371 /* singlet axial-vector corrections */
2372 double I2 = -37.0 / 12.0 + (-log_t) + 7.0 / 81.0 * xt + 0.0132 * xt*xt;
2373 double I3 = -5075.0 / 216.0 + 23.0 / 6.0 * zeta2 + zeta3 + 67.0 / 18.0 * (-log_t)
2374 + 23.0 / 12.0 * log_t*log_t;
2375 double I4 = 49.0309 - 17.6637 * (-log_t) + 14.6597 * log_t * log_t
2376 + 3.6736 * (-log_t * log_t * log_t);
2377
2378 /* rescaled strong coupling constant */
2379 double AlsMzPi = AlsMz / M_PI;
2380 double AlsMzPi2 = AlsMzPi*AlsMzPi;
2381 double AlsMzPi3 = AlsMzPi2*AlsMzPi;
2382 double AlsMzPi4 = AlsMzPi3*AlsMzPi;
2383
2384 /* electromagnetic coupling at Mz */
2385 double alpMz = alphaMz();
2386
2387 /* radiator function to the axial-vector current */
2388 double RAf;
2389 RAf = 1.0 + 3.0 / 4.0 * Qf2 * alpMz / M_PI + AlsMzPi - Qf2 / 4.0 * alpMz / M_PI * AlsMzPi
2390 + (C02 + C2t - 2.0 * I3q * I2) * AlsMzPi2
2391 + (C03 - 2.0 * I3q * I3) * AlsMzPi3
2392 + (C04 - 2.0 * I3q * I4) * AlsMzPi4
2393 + (mcMz2 + mbMz2) / s * C23 * AlsMzPi3
2394 + mqMz2 / s * (C20A + C21A * AlsMzPi + C22A * AlsMzPi2
2395 + 6.0 * (3.0 + log_t) * AlsMzPi2 + C23A * AlsMzPi3)
2396 //- 10.0*mqMz2/pow(quarks[TOP].getMass(),2.0)
2397 - 10.0 * mqMz2 / MtPole / MtPole // the pole mass
2398 * (8.0 / 81.0 + log_t / 54.0) * AlsMzPi2
2399 + mcMz2 * mcMz2 / s / s * (C42 - log_c) * AlsMzPi2
2400 + mbMz2 * mbMz2 / s / s * (C42 - log_b) * AlsMzPi2
2401 + mqMz2 * mqMz2 / s / s * (C40A + C41A * AlsMzPi
2402 + (C42A + C42AL * log_q) * AlsMzPi2)
2403 - 12.0 * mqdash4 / s / s*AlsMzPi2;
2404 return RAf;
2405}
double getZeta4() const
A get method to access the value of the zeta function .
Definition: EWSMcache.h:155
double getZeta5() const
A get method to access the value of the zeta function .
Definition: EWSMcache.h:164
double getZeta3() const
A get method to access the value of the zeta function .
Definition: EWSMcache.h:146
double mf(const Particle f, const double mu=0.0, const orders order=FULLNNLO) const
The mass of an SM fermion.
Definition: EWSMcache.cpp:49
double getZeta2() const
A get method to access the value of the zeta function .
Definition: EWSMcache.h:137
double zeta2
computed with the GSL.
Definition: QCD.h:1032
EWSMcache * getMyEWSMcache() const
A get method to retrieve the member pointer of type EWSMcache.

◆ resumKappaZ()

double StandardModel::resumKappaZ ( const double  DeltaRho[orders_EW_size],
const double  deltaKappa_rem[orders_EW_size],
const double  DeltaRbar_rem,
const bool  bool_Zbb 
) const
protected

A method to compute the real part of the effetvive coupling \(\kappa_Z^f\) from \(\Delta\rho\), \(\delta\rho_{\rm rem}^{f}\) and \(\Delta r_{\mathrm{rem}}\).

This function computes \(\kappa_Z^f\) without or with resummation of \(\Delta\rho\), depending on the model flag KappaZ of StandardModel:

  • NORESUM (recommended):   no resummation is considered;
  • OMSI:   the so-called OMS-I scheme is adopted;
  • INTERMEDIATE:   an intermediate scheme between OMS-I and OMS-II is adopted;
  • OMSII:   the so-called OMS-II scheme is adopted;
  • APPROXIMATEFORMULA:   this is not applicable to the current function.

where the OMS-I, INTERMEDIATE and OMS-II schemes are adopted in ZFITTER [Bardin:1999yd] (see also [Degrassi:1996mg], [Degrassi:1996ps], [Degrassi:1999jd], [Bardin:1999ak]), and used for making comparisons to the outputs of ZFITTER. In all the cases, the two-loop EW corrections are calculated in the large- \(m_t\) expansion.

Parameters
[in]DeltaRhoArray of \(\Delta\rho\)
[in]deltaKappa_remArray of \(\delta\kappa_{\rm rem}^{f}\)
[in]DeltaRbar_remArray of \(\Delta \bar{r}_{\rm rem}\)
[in]bool_Zbbtrue for \(Zb\bar{b}\)
Returns
\(\mathrm{Re}(\kappa_Z^f)\)

Definition at line 2035 of file StandardModel/src/StandardModel.cpp.

2038{
2039 if ((FlagKappaZ.compare("APPROXIMATEFORMULA") == 0)
2040 || (deltaKappa_rem[EW2QCD1] != 0.0)
2041 || (deltaKappa_rem[EW3] != 0.0))
2042 throw std::runtime_error("Error in StandardModel::resumKappaZ()");
2043
2044 if (!flag_order[EW2] && FlagKappaZ.compare("NORESUM") != 0)
2045 throw std::runtime_error("Error in StandardModel::resumKappaZ()");
2046
2047 double Mw_TMP = Mw();
2048 double cW2_TMP = cW2();
2049 double sW2_TMP = sW2();
2050
2051 double f_AlphaToGF, DeltaRho_sum = 0.0, DeltaRho_G;
2052 double DeltaRbar_rem_G, deltaKappa_rem_G, deltaKappa_rem_G2;
2053 // conversion: alpha(0) --> G_F
2054 f_AlphaToGF = sqrt(2.0) * GF * pow(Mz, 2.0)
2055 * sW2_TMP * cW2_TMP / M_PI / ale;
2056 DeltaRho_sum = f_AlphaToGF * DeltaRho[EW1]
2057 + f_AlphaToGF * DeltaRho[EW1QCD1]
2058 + f_AlphaToGF * DeltaRho[EW1QCD2]
2059 + pow(f_AlphaToGF, 2.0) * DeltaRho[EW2]
2060 + pow(f_AlphaToGF, 2.0) * DeltaRho[EW2QCD1]
2061 + pow(f_AlphaToGF, 3.0) * DeltaRho[EW3];
2062 DeltaRho_G = f_AlphaToGF * DeltaRho[EW1];
2063 DeltaRbar_rem_G = f_AlphaToGF*DeltaRbar_rem;
2064 deltaKappa_rem_G = f_AlphaToGF * (deltaKappa_rem[EW1]
2065 + deltaKappa_rem[EW1QCD1]
2066 + deltaKappa_rem[EW1QCD2]);
2067 deltaKappa_rem_G2 = pow(f_AlphaToGF, 2.0) * deltaKappa_rem[EW2];
2068
2069 /* Real parts */
2070 double kappaZ;
2071 if (!bool_Zbb) {
2072 if (FlagKappaZ.compare("OMSI") == 0) {
2073 kappaZ = (1.0 + deltaKappa_rem_G + deltaKappa_rem_G2)
2074 *(1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum * (1.0 - DeltaRbar_rem_G));
2075 } else if (FlagKappaZ.compare("INTERMEDIATE") == 0) {
2076 kappaZ = (1.0 + deltaKappa_rem_G)
2077 *(1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum * (1.0 - DeltaRbar_rem_G))
2078 + deltaKappa_rem_G2;
2079 } else if (FlagKappaZ.compare("NORESUM") == 0
2080 || FlagKappaZ.compare("OMSII") == 0) {
2081 kappaZ = 1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum
2082 - cW2_TMP / sW2_TMP * DeltaRho_G * DeltaRbar_rem_G
2083 + deltaKappa_rem_G * (1.0 + cW2_TMP / sW2_TMP * DeltaRho_G)
2084 + deltaKappa_rem_G2;
2085 } else
2086 throw std::runtime_error("Error in StandardModel::resumKappaZ()");
2087 } else {
2088 /* Z to bb */
2089 double OnePlusTaub = 1.0 + taub();
2090 double kappaZbL;
2091 deltaKappa_rem_G -= f_AlphaToGF * ale / 8.0 / M_PI / sW2_TMP
2092 * pow(mtpole / Mw_TMP, 2.0);
2093 if (FlagKappaZ.compare("NORESUM") == 0) {
2094 kappaZ = (1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum
2095 - cW2_TMP / sW2_TMP * DeltaRho_G * DeltaRbar_rem_G
2096 + deltaKappa_rem_G * (1.0 + cW2_TMP / sW2_TMP * DeltaRho_G)
2097 + deltaKappa_rem_G2) / OnePlusTaub;
2098 } else if (FlagKappaZ.compare("OMSI") == 0) {
2099 kappaZbL = (1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum) / OnePlusTaub;
2100 kappaZ = kappaZbL * (1.0 + deltaKappa_rem_G);
2101 } else if (FlagKappaZ.compare("INTERMEDIATE") == 0
2102 || FlagKappaZ.compare("OMSII") == 0) {
2103 kappaZbL = (1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum) / OnePlusTaub;
2104 kappaZ = kappaZbL + deltaKappa_rem_G;
2105 } else
2106 throw std::runtime_error("Error in StandardModel::resumKappaZ()");
2107 }
2108
2109 return kappaZ;
2110}
double taub() const
Top-mass corrections to the vertex, denoted by .

◆ resumMw()

double StandardModel::resumMw ( const double  Mw_i,
const double  DeltaRho[orders_EW_size],
const double  DeltaR_rem[orders_EW_size] 
) const
protected

A method to compute the \(W\)-boson mass from \(\Delta\rho\) and \(\Delta r_{\mathrm{rem}}\).

This function computes the \(W\)-boson mass without or with resummation of \(\Delta r\), depending on the model flag Mw of StandardModel:

  • NORESUM (recommended):   no resummation is considered;
  • OMSI:   the so-called OMS-I scheme is adopted;
  • INTERMEDIATE:   an intermediate scheme between OMS-I and OMS-II is adopted;
  • OMSII:   the so-called OMS-II scheme is adopted;
  • APPROXIMATEFORMULA:   this is not applicable to the current function.

where the OMS-I, INTERMEDIATE and OMS-II schemes are adopted in ZFITTER [Bardin:1999yd] (see also [Degrassi:1996mg], [Degrassi:1996ps], [Degrassi:1999jd], [Bardin:1999ak]), and used for making comparisons to the outputs of ZFITTER. The full two-loop EW contribution is included in the case of "NORESUM", while the large- \(m_t\) expansion for the two-loop contribution is adopted in the other cases.

In the case of "NORESUM", the two-loop EW contribution to \(\Delta r\) is calculated via the function EWSMApproximateFormulae::DeltaR_TwoLoopEW_rem(), given in the complex-pole/fixed-width scheme. The \(W\)-boson mass in the complex-pole/fixed-width scheme, obtained from \(\Delta r\), is converted into the one in the experimental/running-width scheme with the function MwFromMwbar().

Parameters
[in]Mw_ithe \(W\)-boson mass
[in]DeltaRhoArray of \(\Delta\rho\)
[in]DeltaR_remArray of \(\Delta r_{\mathrm{rem}}\)
Returns
\(M_W\)

Definition at line 1869 of file StandardModel/src/StandardModel.cpp.

1871{
1872 if ((FlagMw.compare("APPROXIMATEFORMULA") == 0)
1873 || (DeltaR_rem[EW2QCD1] != 0.0)
1874 || (DeltaR_rem[EW3] != 0.0))
1875 throw std::runtime_error("Error in StandardModel::resumMw()");
1876
1877 if (!flag_order[EW2] && FlagMw.compare("NORESUM") != 0)
1878 throw std::runtime_error("Error in StandardModel::resumMw()");
1879
1880 double cW2_TMP = Mw_i * Mw_i / Mz / Mz;
1881 double sW2_TMP = 1.0 - cW2_TMP;
1882
1883 double f_AlphaToGF, DeltaRho_sum = 0.0, DeltaRho_G = 0.0;
1884 if (FlagMw.compare("NORESUM") == 0) {
1885 for (int j = 0; j < orders_EW_size; ++j) {
1886 DeltaRho_sum += DeltaRho[(orders_EW) j];
1887 }
1888 } else {
1889 // conversion: alpha(0) --> G_F
1890 f_AlphaToGF = sqrt(2.0) * GF * pow(Mz, 2.0) * sW2_TMP * cW2_TMP / M_PI / ale;
1891 DeltaRho_sum = f_AlphaToGF * DeltaRho[EW1]
1892 + f_AlphaToGF * DeltaRho[EW1QCD1]
1893 + f_AlphaToGF * DeltaRho[EW1QCD2]
1894 + pow(f_AlphaToGF, 2.0) * DeltaRho[EW2]
1895 + pow(f_AlphaToGF, 2.0) * DeltaRho[EW2QCD1]
1896 + pow(f_AlphaToGF, 3.0) * DeltaRho[EW3];
1897 DeltaRho_G = f_AlphaToGF * DeltaRho[EW1];
1898 }
1899
1900 double R;
1901 double DeltaR_rem_sum = 0.0;
1902 double DeltaR_EW1 = 0.0, DeltaR_EW2_rem = 0.0;
1903 if (FlagMw.compare("NORESUM") == 0) {
1904 for (int j = 0; j < orders_EW_size; ++j)
1905 DeltaR_rem_sum += DeltaR_rem[(orders_EW) j];
1906
1907 // Full EW one-loop contribution (without the full DeltaAlphaL5q)
1908 DeltaR_EW1 = -cW2_TMP / sW2_TMP * DeltaRho[EW1] + DeltaR_rem[EW1];
1909
1910 // Full EW two-loop contribution without reducible corrections
1911 DeltaR_EW2_rem = myApproximateFormulae->DeltaR_TwoLoopEW_rem(Mw_i);
1912
1913 // subtract the EW two-loop contributions from DeltaRho_sum and DeltaR_rem_sum
1914 DeltaRho_sum -= DeltaRho[EW2];
1915 DeltaR_rem_sum -= DeltaR_rem[EW2];
1916
1917 // R = 1 + Delta r, including the full EW two-loop contribution
1918 R = 1.0 + DeltaAlphaL5q() - cW2_TMP / sW2_TMP * DeltaRho_sum
1919 + DeltaR_rem_sum;
1920 R += DeltaAlphaL5q() * DeltaAlphaL5q() + 2.0 * DeltaAlphaL5q() * DeltaR_EW1
1921 + DeltaR_EW2_rem;
1922 } else if (FlagMw.compare("OMSI") == 0) {
1923 // R = 1/(1 - Delta r)
1924 R = 1.0 / (1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum)
1925 / (1.0 - DeltaAlphaL5q()
1926 - DeltaR_rem[EW1] - DeltaR_rem[EW1QCD1] - DeltaR_rem[EW2]);
1927 } else if (FlagMw.compare("INTERMEDIATE") == 0) {
1928 // R = 1/(1 - Delta r)
1929 R = 1.0 / ((1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum)
1930 *(1.0 - DeltaAlphaL5q() - DeltaR_rem[EW1])
1931 - DeltaR_rem[EW1QCD1] - DeltaR_rem[EW2]);
1932 } else if (FlagMw.compare("OMSII") == 0) {
1933 // R = 1/(1 - Delta r)
1934 R = 1.0 / ((1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum)*(1.0 - DeltaAlphaL5q())
1935 - (1.0 + cW2_TMP / sW2_TMP * DeltaRho_G) * DeltaR_rem[EW1]
1936 - DeltaR_rem[EW1QCD1] - DeltaR_rem[EW2]);
1937 } else
1938 throw std::runtime_error("Error in StandardModel::resumMw()");
1939
1940 if (FlagMw.compare("NORESUM") == 0) {
1941 /* Mzbar and Mwbar are defined in the complex-pole scheme. */
1942
1943 double tmp = 4.0 * M_PI * ale / sqrt(2.0) / GF / Mzbar() / Mzbar();
1944 if (tmp * R > 1.0) throw std::runtime_error("StandardModel::resumMw(): Negative (1-tmp*R)");
1945 double Mwbar = Mzbar() / sqrt(2.0) * sqrt(1.0 + sqrt(1.0 - tmp * R));
1946
1947 return MwFromMwbar(Mwbar);
1948 } else {
1949 double tmp = 4.0 * M_PI * ale / sqrt(2.0) / GF / Mz / Mz;
1950 if (tmp * R > 1.0) throw std::runtime_error("StandardModel::resumMw(): Negative (1-tmp*R)");
1951
1952 return (Mz / sqrt(2.0) * sqrt(1.0 + sqrt(1.0 - tmp * R)));
1953 }
1954}
double DeltaR_TwoLoopEW_rem(const double Mw_i) const
.
const double MwFromMwbar(const double Mwbar) const
A method to convert the -boson mass in the complex-pole/fixed-width scheme to that in the experimenta...
orders_EW
An enumerated type representing perturbative orders of radiative corrections to EW precision observab...

◆ resumRhoZ()

double StandardModel::resumRhoZ ( const double  DeltaRho[orders_EW_size],
const double  deltaRho_rem[orders_EW_size],
const double  DeltaRbar_rem,
const bool  bool_Zbb 
) const
protected

A method to compute the real part of the effective coupling \(\rho_Z^f\) from \(\Delta\rho\), \(\delta\rho_{\rm rem}^{f}\) and \(\Delta r_{\mathrm{rem}}\).

This function computes \(\rho_Z^f\) without or with resummation of \(\Delta\rho\), depending on the model flag RhoZ of StandardModel:

  • NORESUM (recommended):   no resummation is considered;
  • OMSI:   the so-called OMS-I scheme is adopted;
  • INTERMEDIATE:   an intermediate scheme between OMS-I and OMS-II is adopted;
  • OMSII:   the so-called OMS-II scheme is adopted;
  • APPROXIMATEFORMULA:   this is not applicable to the current function.

where the OMS-I, INTERMEDIATE and OMS-II schemes are adopted in ZFITTER [Bardin:1999yd] (see also [Degrassi:1996mg], [Degrassi:1996ps], [Degrassi:1999jd], [Bardin:1999ak]), and used for making comparisons to the outputs of ZFITTER. In all the cases, the two-loop EW corrections are calculated in the large- \(m_t\) expansion.

Parameters
[in]DeltaRhoArray of \(\Delta\rho\)
[in]deltaRho_remArray of \(\delta\rho_{\rm rem}^{f}\)
[in]DeltaRbar_remArray of \(\Delta \bar{r}_{\rm rem}\)
[in]bool_Zbbtrue for \(Zb\bar{b}\)
Returns
\(\mathrm{Re}(\rho_Z^f)\)

Definition at line 1956 of file StandardModel/src/StandardModel.cpp.

1959{
1960 if ((FlagRhoZ.compare("APPROXIMATEFORMULA") == 0)
1961 || (deltaRho_rem[EW1QCD2] != 0.0)
1962 || (deltaRho_rem[EW2QCD1] != 0.0)
1963 || (deltaRho_rem[EW3] != 0.0))
1964 throw std::runtime_error("Error in StandardModel::resumRhoZ()");
1965
1966 if (!flag_order[EW2] && FlagRhoZ.compare("NORESUM") != 0)
1967 throw std::runtime_error("Error in StandardModel::resumRhoZ()");
1968
1969 double Mw_TMP = Mw();
1970 double cW2_TMP = cW2();
1971 double sW2_TMP = sW2();
1972
1973 double f_AlphaToGF, DeltaRho_sum = 0.0, DeltaRho_G;
1974 double DeltaRbar_rem_G, deltaRho_rem_G, deltaRho_rem_G2;
1975 // conversion: alpha(0) --> G_F
1976 f_AlphaToGF = sqrt(2.0) * GF * pow(Mz, 2.0)
1977 * sW2_TMP * cW2_TMP / M_PI / ale;
1978 DeltaRho_sum = f_AlphaToGF * DeltaRho[EW1]
1979 + f_AlphaToGF * DeltaRho[EW1QCD1]
1980 + f_AlphaToGF * DeltaRho[EW1QCD2]
1981 + pow(f_AlphaToGF, 2.0) * DeltaRho[EW2]
1982 + pow(f_AlphaToGF, 2.0) * DeltaRho[EW2QCD1]
1983 + pow(f_AlphaToGF, 3.0) * DeltaRho[EW3];
1984 DeltaRho_G = f_AlphaToGF * DeltaRho[EW1];
1985 DeltaRbar_rem_G = f_AlphaToGF*DeltaRbar_rem;
1986 deltaRho_rem_G = f_AlphaToGF * (deltaRho_rem[EW1]
1987 + deltaRho_rem[EW1QCD1]);
1988 deltaRho_rem_G2 = pow(f_AlphaToGF, 2.0) * deltaRho_rem[EW2];
1989
1990 /* Real parts */
1991 double rhoZ;
1992 if (!bool_Zbb) {
1993 if (FlagRhoZ.compare("OMSI") == 0) {
1994 rhoZ = (1.0 + deltaRho_rem_G + deltaRho_rem_G2)
1995 / (1.0 - DeltaRho_sum * (1.0 - DeltaRbar_rem_G));
1996 } else if (FlagRhoZ.compare("INTERMEDIATE") == 0) {
1997 rhoZ = (1.0 + deltaRho_rem_G)
1998 / (1.0 - DeltaRho_sum * (1.0 - DeltaRbar_rem_G))
1999 + deltaRho_rem_G2;
2000 } else if (FlagRhoZ.compare("NORESUM") == 0
2001 || FlagRhoZ.compare("OMSII") == 0) {
2002 rhoZ = 1.0 + DeltaRho_sum - DeltaRho_G * DeltaRbar_rem_G
2003 + DeltaRho_G * DeltaRho_G
2004 + deltaRho_rem_G * (1.0 + DeltaRho_G) + deltaRho_rem_G2;
2005 } else
2006 throw std::runtime_error("Error in StandardModel::resumRhoZ()");
2007 } else {
2008 /* Z to bb */
2009 double OnePlusTaub = 1.0 + taub();
2010 double OnePlusTaub2 = OnePlusTaub*OnePlusTaub;
2011 double rhoZbL;
2012 deltaRho_rem_G += f_AlphaToGF * ale / 4.0 / M_PI / sW2_TMP
2013 * pow(mtpole / Mw_TMP, 2.0);
2014 if (FlagRhoZ.compare("NORESUM") == 0) {
2015 rhoZ = (1.0 + DeltaRho_sum - DeltaRho_G * DeltaRbar_rem_G
2016 + DeltaRho_G * DeltaRho_G
2017 + deltaRho_rem_G * (1.0 + DeltaRho_G) + deltaRho_rem_G2)
2018 * OnePlusTaub2;
2019 } else if (FlagRhoZ.compare("OMSI") == 0) {
2020 rhoZbL = OnePlusTaub2 / (1.0 - DeltaRho_sum);
2021 rhoZ = rhoZbL / (1.0 - rhoZbL * deltaRho_rem_G);
2022 } else if (FlagRhoZ.compare("INTERMEDIATE") == 0) {
2023 rhoZbL = OnePlusTaub2 / (1.0 - DeltaRho_sum);
2024 rhoZ = rhoZbL * (1.0 + rhoZbL * deltaRho_rem_G);
2025 } else if (FlagRhoZ.compare("OMSII") == 0) {
2026 rhoZbL = OnePlusTaub2 / (1.0 - DeltaRho_sum);
2027 rhoZ = rhoZbL * (1.0 + deltaRho_rem_G);
2028 } else
2029 throw std::runtime_error("Error in StandardModel::resumRhoZ()");
2030 }
2031
2032 return rhoZ;
2033}

◆ rho_GammaW()

const double StandardModel::rho_GammaW ( const Particle  fi,
const Particle  fj 
) const
virtual

EW radiative corrections to the width of \(W \to f_i \bar{f}_j\), denoted as \(\rho^W_{ij}\).

Parameters
[in]fia lepton or quark
[in]fja lepton or quark
Returns
\(\rho^W_{ij}\)
See also
EWSMOneLoopEW::rho_GammaW()

Definition at line 1233 of file StandardModel/src/StandardModel.cpp.

1234{
1235 double rhoW = 0.0;
1236 if (flag_order[EW1])
1237 rhoW = myOneLoopEW->rho_GammaW(fi, fj, Mw());
1238 return rhoW;
1239}
double rho_GammaW(const Particle fi, const Particle fj, const double Mw_i) const
EW radiative corrections to the width of , denoted as .

◆ rhoZ_f()

const gslpp::complex StandardModel::rhoZ_f ( const Particle  f) const
virtual

The effective leptonic neutral-current coupling \(\rho_Z^l\) in the SM.

This function collects the radiative corrections to \(\rho_Z^l\) computed via EWSMOneLoopEW, EWSMTwoLoopQCD, EWSMTwoLoopEW, EWSMThreeLoopQCD, EWSMThreeLoopEW2QCD and EWSMThreeLoopEW classes. The real part is computed with the function resumRhoZ(), while only the one-loop contribution is kept in the imaginary part.

Parameters
[in]fa lepton or quark
Returns
\(\rho_{Z,\,\mathrm{SM}}^l\)
See also
resumRhoZ()
Attention
If the model flag CacheInStandardModel of StandardModel is set to true, the caching method implemented in the current class is employed.

Reimplemented in NPbase, and NPEpsilons.

Definition at line 1587 of file StandardModel/src/StandardModel.cpp.

1588{
1589 if (f.getName().compare("TOP") == 0) return (gslpp::complex(0.0, 0.0, false));
1590 if (FlagRhoZ.compare("APPROXIMATEFORMULA") == 0)
1591 throw std::runtime_error("No approximate formula is available for rhoZ^f");
1592 else {
1593
1595 if (useRhoZ_f_cache[f.getIndex()])
1596 return rhoZ_f_cache[f.getIndex()];
1597
1598 double myMw = Mw();
1599
1600 /* compute Delta rho */
1601 double DeltaRho[orders_EW_size];
1602 ComputeDeltaRho(myMw, DeltaRho);
1603
1604 /* compute delta rho_rem^f */
1605 gslpp::complex deltaRho_remf[orders_EW_size];
1606 deltaRho_remf[EW1] = gslpp::complex(0.0, 0.0, false);
1607 deltaRho_remf[EW1QCD1] = gslpp::complex(0.0, 0.0, false);
1608 deltaRho_remf[EW1QCD2] = gslpp::complex(0.0, 0.0, false);
1609 deltaRho_remf[EW2] = gslpp::complex(0.0, 0.0, false);
1610 deltaRho_remf[EW2QCD1] = gslpp::complex(0.0, 0.0, false);
1611 deltaRho_remf[EW3] = gslpp::complex(0.0, 0.0, false);
1612 if (flag_order[EW1])
1613 deltaRho_remf[EW1] = myOneLoopEW->deltaRho_rem_f(f, myMw);
1614 if (flag_order[EW1QCD1])
1615#ifdef WITHIMTWOLOOPQCD
1616 deltaRho_remf[EW1QCD1] = gslpp::complex(myTwoLoopQCD->deltaRho_rem_f(f, myMw).real(),
1617 myTwoLoopQCD->deltaRho_rem_f(f, myMw).imag(), false);
1618#else
1619 deltaRho_remf[EW1QCD1] = gslpp::complex(myTwoLoopQCD->deltaRho_rem_f(f, myMw).real(), 0.0, false);
1620#endif
1621 if (flag_order[EW1QCD2])
1622 deltaRho_remf[EW1QCD2] = gslpp::complex(myThreeLoopQCD->deltaRho_rem_f(f, myMw).real(), 0.0, false);
1623 if (flag_order[EW2])
1624 deltaRho_remf[EW2] = gslpp::complex(myTwoLoopEW->deltaRho_rem_f(f, myMw).real(), 0.0, false);
1625 if (flag_order[EW2QCD1])
1626 deltaRho_remf[EW2QCD1] = gslpp::complex(myThreeLoopEW2QCD->deltaRho_rem_f(f, myMw).real(), 0.0, false);
1627 if (flag_order[EW3])
1628 deltaRho_remf[EW3] = gslpp::complex(myThreeLoopEW->deltaRho_rem_f(f, myMw).real(), 0.0, false);
1629
1630 /* compute Delta rbar_rem */
1631 double DeltaRbar_rem = 0.0;
1632 if (flag_order[EW1])
1633 DeltaRbar_rem = myOneLoopEW->DeltaRbar_rem(myMw);
1634
1635 /* Re[rho_Z^f] with or without resummation */
1636 double deltaRho_rem_f_real[orders_EW_size];
1637 for (int j = 0; j < orders_EW_size; ++j)
1638 deltaRho_rem_f_real[j] = deltaRho_remf[j].real();
1639 double ReRhoZf = resumRhoZ(DeltaRho, deltaRho_rem_f_real, DeltaRbar_rem, f.is("BOTTOM"));
1640
1641 /* Im[rho_Z^f] without resummation */
1642 double ImRhoZf = 0.0;
1643 for (int j = 0; j < orders_EW_size; ++j)
1644 ImRhoZf += deltaRho_remf[j].imag();
1645
1646 rhoZ_f_cache[f.getIndex()] = gslpp::complex(ReRhoZf, ImRhoZf, false);
1647 useRhoZ_f_cache[f.getIndex()] = true;
1648 return (gslpp::complex(ReRhoZf, ImRhoZf, false));
1649 }
1650}
gslpp::complex deltaRho_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
gslpp::complex deltaRho_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
gslpp::complex deltaRho_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
gslpp::complex deltaRho_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
gslpp::complex deltaRho_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
gslpp::complex deltaRho_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
std::string getName() const
Definition: Particle.h:147
double resumRhoZ(const double DeltaRho[orders_EW_size], const double deltaRho_rem[orders_EW_size], const double DeltaRbar_rem, const bool bool_Zbb) const
A method to compute the real part of the effective coupling from , and .

◆ Ruc()

const double StandardModel::Ruc ( ) const
virtual

Reimplemented in NPbase.

Definition at line 1316 of file StandardModel/src/StandardModel.cpp.

1317{
1318 return 0.5 * ( R0_f(quarks[UP]) + R0_f(quarks[CHARM]) );
1319}

◆ RVh()

double StandardModel::RVh ( ) const
protected

The singlet vector corrections to the hadronic \(Z\)-boson width, denoted as \(R_V^h\).

In addition to the final-state corrections represented by the radiator factors \(R_V^q(M_Z^2)\) and \(R_A^q(M_Z^2)\), there exist singlet vector corrections to the total hadronic width [Chetyrkin:1994js], [Baikov:2012er], which is much smaller than the other corrections.

The assignment of the singlet vector corrections to the partial widths is ambiguous [Bardin:1997xq]. See Gamma_had() for our prescription.

Returns
\(R_V^h\)

Definition at line 2407 of file StandardModel/src/StandardModel.cpp.

2408{
2409 /* rescaled strong coupling constant */
2410 double AlsMzPi = AlsMz / M_PI;
2411 double AlsMzPi2 = AlsMzPi*AlsMzPi;
2412 double AlsMzPi3 = AlsMzPi2*AlsMzPi;
2413 double AlsMzPi4 = AlsMzPi3*AlsMzPi;
2414
2415 gslpp::complex gV_sum(0.0, 0.0);
2416 gslpp::complex gV_q;
2417 for (int q = 0; q < 6; q++) {
2418 gV_q = gV_f(QCD::quarks[(QCD::quark)q]);
2419 if (q == (int) (QCD::TOP))
2420 gV_q = 0.0;
2421 gV_sum += gV_q;
2422 }
2423
2424 // singlet vector corrections
2425 return ( gV_sum.abs2()*(-0.4132 * AlsMzPi3 - 4.9841 * AlsMzPi4));
2426}

◆ RVq()

double StandardModel::RVq ( const QCD::quark  q) const
protected

The radiator factor associated with the final-state QED and QCD corrections to the the vector-current interactions, \(R_V^q(M_Z^2)\).

See [Chetyrkin:1994js], [Bardin:1999ak], [Bardin:1999yd] and references therein.

Parameters
[in]qname of a quark (see QCD::quark)
Returns
\(R_V^q(M_Z^2)\)

Definition at line 2150 of file StandardModel/src/StandardModel.cpp.

2151{
2152 if (q == QCD::TOP) return 0.0;
2153
2154 double mcMz, mbMz;
2157 //mcMz = 0.56381685; /* for debug */
2158 //mbMz = 2.8194352; /* for debug */
2159
2160 double MtPole = mtpole;
2161
2162 /* electric charge squared */
2163 double Qf2 = pow(quarks[q].getCharge(), 2.0);
2164
2165 /* s = Mz^2 */
2166 double s = Mz * Mz;
2167
2168 /* products of the charm and bottom masses at Mz */
2169 double mcMz2 = mcMz*mcMz;
2170 double mbMz2 = mbMz*mbMz;
2171 double mqMz2, mqdash4;
2172 switch (q) {
2173 case QCD::CHARM:
2174 mqMz2 = mcMz*mcMz;
2175 mqdash4 = mbMz2*mbMz2;
2176 break;
2177 case QCD::BOTTOM:
2178 mqMz2 = mbMz*mbMz;
2179 mqdash4 = mcMz2*mcMz2;
2180 break;
2181 default:
2182 mqMz2 = 0.0;
2183 mqdash4 = 0.0;
2184 break;
2185 }
2186
2187 /* Logarithms */
2188 //double log_t = log(pow(quarks[TOP].getMass(),2.0)/s);
2189 double log_t = log(MtPole * MtPole / s); // the pole mass
2190 double log_c = log(mcMz2 / s);
2191 double log_b = log(mbMz2 / s);
2192 double log_q;
2193 switch (q) {
2194 case QCD::CHARM:
2195 case QCD::BOTTOM:
2196 log_q = log(mqMz2 / s);
2197 break;
2198 default:
2199 log_q = 0.0;
2200 break;
2201 }
2202
2203 /* the active number of flavour */
2204 double nf = 5.0;
2205
2206 /* zeta functions */
2207 double zeta2 = getMyEWSMcache()->getZeta2();
2208 double zeta3 = getMyEWSMcache()->getZeta3();
2209 //double zeta4 = getMyCache()->GetZeta4();
2210 double zeta5 = getMyEWSMcache()->getZeta5();
2211
2212 /* massless non-singlet corrections */
2213 double C02 = 365.0 / 24.0 - 11.0 * zeta3 + (-11.0 / 12.0 + 2.0 / 3.0 * zeta3) * nf;
2214 double C03 = 87029.0 / 288.0 - 121.0 / 8.0 * zeta2 - 1103.0 / 4.0 * zeta3
2215 + 275.0 / 6.0 * zeta5
2216 + (-7847.0 / 216.0 + 11.0 / 6.0 * zeta2 + 262.0 / 9.0 * zeta3
2217 - 25.0 / 9.0 * zeta5) * nf
2218 + (151.0 / 162.0 - zeta2 / 18.0 - 19.0 / 27.0 * zeta3) * nf*nf;
2219 double C04 = -156.61 + 18.77 * nf - 0.7974 * nf * nf + 0.0215 * nf * nf*nf;
2220 //std::cout << "TEST: C02 = " << C02 << std::endl;// TEST (should be 1.40923)
2221 //std::cout << "TEST: C03 = " << C03 << std::endl;// TEST (should be -12.7671)
2222 //std::cout << "TEST: C04 = " << C04 << std::endl;// TEST (should be -80.0075)
2223
2224 /* quadratic massive corrections */
2225 double C23 = -80.0 + 60.0 * zeta3 + (32.0 / 9.0 - 8.0 / 3.0 * zeta3) * nf;
2226 double C21V = 12.0;
2227 double C22V = 253.0 / 2.0 - 13.0 / 3.0 * nf;
2228 double C23V = 2522.0 - 855.0 / 2.0 * zeta2 + 310.0 / 3.0 * zeta3 - 5225.0 / 6.0 * zeta5
2229 + (-4942.0 / 27.0 + 34.0 * zeta2 - 394.0 / 27.0 * zeta3
2230 + 1045.0 / 27.0 * zeta5) * nf
2231 + (125.0 / 54.0 - 2.0 / 3.0 * zeta2) * nf*nf;
2232
2233 /* quartic massive corrections */
2234 double C42 = 13.0 / 3.0 - 4.0 * zeta3;
2235 double C40V = -6.0;
2236 double C41V = -22.0;
2237 double C42V = -3029.0 / 12.0 + 162.0 * zeta2 + 112.0 * zeta3
2238 + (143.0 / 18.0 - 4.0 * zeta2 - 8.0 / 3.0 * zeta3) * nf;
2239 double C42VL = -11.0 / 2.0 + nf / 3.0;
2240
2241 /* power suppressed top-mass correction */
2242 //double xt = s/pow(quarks[TOP].getMass(),2.0);
2243 double xt = s / MtPole / MtPole; // the pole mass
2244 double C2t = xt * (44.0 / 675.0 - 2.0 / 135.0 * (-log_t));
2245
2246 /* rescaled strong coupling constant */
2247 double AlsMzPi = AlsMz / M_PI;
2248 double AlsMzPi2 = AlsMzPi*AlsMzPi;
2249 double AlsMzPi3 = AlsMzPi2*AlsMzPi;
2250 double AlsMzPi4 = AlsMzPi3*AlsMzPi;
2251
2252 /* electromagnetic coupling at Mz */
2253 double alpMz = alphaMz();
2254
2255 /* radiator function to the vector current */
2256 double RVf;
2257 RVf = 1.0 + 3.0 / 4.0 * Qf2 * alpMz / M_PI + AlsMzPi - Qf2 / 4.0 * alpMz / M_PI * AlsMzPi
2258 + (C02 + C2t) * AlsMzPi2 + C03 * AlsMzPi3 + C04 * AlsMzPi4
2259 + (mcMz2 + mbMz2) / s * C23 * AlsMzPi3
2260 + mqMz2 / s * (C21V * AlsMzPi + C22V * AlsMzPi2 + C23V * AlsMzPi3)
2261 + mcMz2 * mcMz2 / s / s * (C42 - log_c) * AlsMzPi2
2262 + mbMz2 * mbMz2 / s / s * (C42 - log_b) * AlsMzPi2
2263 + mqMz2 * mqMz2 / s / s * (C40V + C41V * AlsMzPi + (C42V + C42VL * log_q) * AlsMzPi2)
2264 + 12.0 * mqdash4 / s / s * AlsMzPi2
2265 - mqMz2 * mqMz2 * mqMz2 / s / s / s
2266 * (8.0 + 16.0 / 27.0 * (155.0 + 6.0 * log_q) * AlsMzPi);
2267 return RVf;
2268}

◆ RWc()

const double StandardModel::RWc ( ) const
virtual

The ratio \(R_{W,c)=\Gamma(W\to c + X)/\Gamma(W\to had)\).

Returns
\(R_{W,c)\) in GeV

Reimplemented in NPbase, NPSMEFTd6, and NPSMEFTd6General.

Definition at line 1321 of file StandardModel/src/StandardModel.cpp.

1322{
1323 double GammWcX, GammWhad;
1324
1325// Add all the W-> cX decays
1326// In GammaW fermion masses are ignored and CKM=1 but uses that SM CKM is unitary => I only need W->cs
1327 GammWcX = GammaW(quarks[CHARM], quarks[STRANGE]);
1328
1329// For the same reasons, I only need to add the W-> ud decays into the hadronic part
1330 GammWhad = GammWcX
1331 + GammaW(quarks[UP], quarks[DOWN]);
1332
1333 return GammWcX/GammWhad;
1334}

◆ RWlilj()

const double StandardModel::RWlilj ( const Particle  li,
const Particle  lj 
) const
virtual

The lepton universality ratio \(R_{W,l_i/l_j)=\Gamma(W\to l_i \nu_i)/\Gamma(W\to l_j \nu_j)\).

Returns
\(R_{W,l_i/l_j)\) in GeV

Reimplemented in NPbase, NPSMEFTd6, and NPSMEFTd6General.

Definition at line 1291 of file StandardModel/src/StandardModel.cpp.

1292{
1293 double GammWli, GammWlj;
1294
1295 if (li.is("ELECTRON"))
1296 GammWli = GammaW(leptons[NEUTRINO_1],li);
1297 else if (li.is("MU"))
1298 GammWli = GammaW(leptons[NEUTRINO_2],li);
1299 else if (li.is("TAU"))
1300 GammWli = GammaW(leptons[NEUTRINO_3],li);
1301 else
1302 throw std::runtime_error("Error in StandardModel::RWlilj. li must be a charged lepton");
1303
1304 if (lj.is("ELECTRON"))
1305 GammWlj = GammaW(leptons[NEUTRINO_1],lj);
1306 else if (lj.is("MU"))
1307 GammWlj = GammaW(leptons[NEUTRINO_2],lj);
1308 else if (lj.is("TAU"))
1309 GammWlj = GammaW(leptons[NEUTRINO_3],lj);
1310 else
1311 throw std::runtime_error("Error in StandardModel::RWlilj. lj must be a charged lepton");
1312
1313 return GammWli/GammWlj;
1314}

◆ RZlilj()

const double StandardModel::RZlilj ( const Particle  li,
const Particle  lj 
) const
virtual

The lepton universality ratio \(R_{Z,l_i/l_j)=\Gamma(Z\to l_i^+ l_i^-)/\Gamma(Z\to l_j^+ l_j^-)\).

Returns
\(R_{Z,l_i/l_j)\) in GeV

Reimplemented in NPbase, NPSMEFTd6, and NPSMEFTd6General.

Definition at line 1446 of file StandardModel/src/StandardModel.cpp.

1447{
1448 double GammZli, GammZlj;
1449
1450 if ( li.is("ELECTRON") || li.is("MU") || li.is("TAU") )
1451 GammZli = GammaZ(li);
1452 else
1453 throw std::runtime_error("Error in StandardModel::RZlilj. li must be a charged lepton");
1454
1455 if ( lj.is("ELECTRON") || lj.is("MU") || lj.is("TAU") )
1456 GammZlj = GammaZ(lj);
1457 else
1458 throw std::runtime_error("Error in StandardModel::RZlilj. lj must be a charged lepton");
1459
1460 return GammZli/GammZlj;
1461}

◆ s02()

const double StandardModel::s02 ( ) const

The square of the sine of the weak mixing angle \(s_0^2\) defined without weak radiative corrections.

The quantity \(s_0^2\) is defined through

\[ s_0^2 c_0^2 = \frac{\pi\,\alpha(M_Z^2)}{\sqrt{2}\,G_\mu M_Z^2} \ \ \rightarrow\ \ s_0^2 = \frac{1}{2} \left(1 - \sqrt{1 - \frac{4\pi \alpha(M_Z^2)}{\sqrt{2}\,G_\mu M_Z^2}}\ \right)\,. \]

See [Altarelli:1990zd] and [Altarelli:1991fk].

Returns
\(s_0^2\)

Definition at line 1004 of file StandardModel/src/StandardModel.cpp.

1005{
1006 double tmp = 1.0 - 4.0 * M_PI * alphaMz() / sqrt(2.0) / GF / Mz / Mz;
1007 if (tmp < 0.0)
1008 throw std::runtime_error("Error in s02()");
1009
1010 return ( (1.0 - sqrt(tmp)) / 2.0);
1011}

◆ SchemeToDouble()

double StandardModel::SchemeToDouble ( const std::string  scheme) const
inlineprotected

A method to convert a given scheme name in string form into a floating-point number with double precision.

This method is used in EWSM::checkSMparams() for caching the schemes used in computing \(M_W\), \(\rho_Z^f\) and \(\kappa_Z^f\).

Parameters
[in]schemescheme name that is used in computing \(M_W\), \(\rho_Z^f\) or \(\kappa_Z^f\)
Returns
a floating-point number with double precision corresponding to the given scheme name

Definition at line 3479 of file StandardModel.h.

3480 {
3481 if (scheme.compare("NORESUM") == 0)
3482 return 0.0;
3483 else if (scheme.compare("OMSI") == 0)
3484 return 1.0;
3485 else if (scheme.compare("INTERMEDIATE") == 0)
3486 return 2.0;
3487 else if (scheme.compare("OMSII") == 0)
3488 return 3.0;
3489 else if (scheme.compare("APPROXIMATEFORMULA") == 0)
3490 return 4.0;
3491 else
3492 throw std::runtime_error("EWSM::SchemeToDouble: bad scheme");
3493 }

◆ setCKM()

void StandardModel::setCKM ( const CKM CKMMatrix)
inline

A set method to change the CKM matrix.

Parameters
[in]CKMMatrixa reference to the new CKM matrix

Definition at line 3328 of file StandardModel.h.

3329 {
3330 myCKM = CKMMatrix;
3331 }

◆ setFlag()

bool StandardModel::setFlag ( const std::string  name,
const bool  value 
)
virtual

A method to set a flag of StandardModel.

Parameters
[in]namename of a model flag
[in]valuethe boolean to be assigned to the flag specified by name
Returns
a boolean that is true if the execution is successful

Reimplemented from QCD.

Reimplemented in FlavourWilsonCoefficient, LoopMediators, RealWeakEFTCC, RealWeakEFTLFV, HiggsChiral, HiggsKigen, NPEpsilons, NPSMEFTd6, NPSMEFTd6General, THDM, GeorgiMachacek, LeftRightSymmetricModel, NPSMEFT6dtopquark, and SUSY.

Definition at line 442 of file StandardModel/src/StandardModel.cpp.

443{
444 bool res = false;
445 if (name.compare("CacheInStandardModel") == 0) {
447 res = true;
448 } else if (name.compare("CacheInEWSMcache") == 0) {
450 res = true;
451 } else if (name.compare("Wolfenstein") == 0) {
452 FlagWolfenstein = value;
453 if(!FlagWolfenstein) {
454 SMvars[std::distance(SMvars,std::find(SMvars,SMvars+NSMvars,"lambda"))] = "V_us";
455 SMvars[std::distance(SMvars,std::find(SMvars,SMvars+NSMvars,"A"))] = "V_cb";
456 SMvars[std::distance(SMvars,std::find(SMvars,SMvars+NSMvars,"rhob"))] = "V_ub";
457 SMvars[std::distance(SMvars,std::find(SMvars,SMvars+NSMvars,"etab"))] = "gamma";
458
459 ModelParamMap.insert(std::make_pair("V_us", std::cref(Vus)));
460 ModelParamMap.insert(std::make_pair("V_cb", std::cref(Vcb)));
461 ModelParamMap.insert(std::make_pair("V_ub", std::cref(Vub)));
462 ModelParamMap.insert(std::make_pair("gamma", std::cref(gamma)));
463 }
464 res = true;
465 } else if (name.compare("WithoutNonUniversalVC") == 0) {
467 res = true;
468 } else if (name.compare("NoApproximateGammaZ") == 0) {
470 res = true;
471 } else if (name.compare("MWinput") == 0) {
472 FlagMWinput = value;
473 if (FlagMWinput) {
474 SMvars[std::distance(SMvars,std::find(SMvars,SMvars+NSMvars,"dAle5Mz"))] = "Mw_inp";
475 ModelParamMap.insert(std::make_pair("Mw_inp", std::cref(Mw_inp)));
476 // Point the different flags towards the approximate formulae, when available
478 FlagMw = "APPROXIMATEFORMULA";
479 FlagRhoZ = "NORESUM";
480 FlagKappaZ = "APPROXIMATEFORMULA";
481 }
482 res = true;
483 } else if (name.compare("SMAux") == 0) {
484 FlagSMAux = value;
485 res = true;
486 } else if (name.compare("FixMuwMut") == 0) {
487 FlagFixMuwMut = value;
488 res = true;
489 } else if (name.compare("UseVud") == 0) {
490 FlagUseVud = value;
492 throw std::runtime_error("UseVud can only be used when Wolfenstein is false");
493 else if(FlagUseVud) {
494 SMvars[std::distance(SMvars,std::find(SMvars,SMvars+NSMvars,"V_us"))] = "V_ud";
495 ModelParamMap.erase("V_us");
496 ModelParamMap.insert(std::make_pair("V_ud", std::cref(Vud)));
497 }
498 res = true;
499 } else
500 res = QCD::setFlag(name, value);
501
502 if (!res) res = SMFlavour.setFlag(name, value);
503
504 return (res);
505}
void setFlagCacheInEWSMcache(bool FlagCacheInEWSMcache)
A set method to change the model flag CacheInEWSMcache in StandardModel.
Definition: EWSMcache.h:83
bool setFlag(const std::string name, const bool value)
Definition: Flavour.cpp:33
std::string name
The name of the model.
Definition: Model.h:285
virtual bool setFlag(const std::string name, const bool value)
A method to set a flag of QCD.
Definition: QCD.cpp:479
void setFlagCacheInStandardModel(bool FlagCacheInStandardModel)
A set method to change the model flag CacheInStandardModel of StandardModel.

◆ setFlagCacheInStandardModel()

void StandardModel::setFlagCacheInStandardModel ( bool  FlagCacheInStandardModel)
inline

A set method to change the model flag CacheInStandardModel of StandardModel.

Setting CacheInStandardModel to false, the caching methods defined in the current class are not employed in numerical computations. The flag is set to true in the constructor EWSM() by default.

Parameters
[in]FlagCacheInStandardModeltrue (false) if the caching methods are turned on (off);
See also
the description of the StandardModel flags

Definition at line 730 of file StandardModel.h.

◆ setFlagNoApproximateGammaZ()

void StandardModel::setFlagNoApproximateGammaZ ( bool  FlagNoApproximateGammaZ)
inline

Definition at line 684 of file StandardModel.h.

◆ setFlagSigmaForAFB()

bool StandardModel::setFlagSigmaForAFB ( const bool  flagSigmaForAFB_i)
inline

Definition at line 3292 of file StandardModel.h.

3293{
3294 bSigmaForAFB = flagSigmaForAFB_i;
3295 return true;
3296}

◆ setFlagSigmaForR()

bool StandardModel::setFlagSigmaForR ( const bool  flagSigmaForR_i)
inline

Definition at line 3298 of file StandardModel.h.

3299{
3300 bSigmaForR = flagSigmaForR_i;
3301 return true;
3302}

◆ setFlagStr()

bool StandardModel::setFlagStr ( const std::string  name,
const std::string  value 
)
virtual

A method to set a flag of StandardModel.

Parameters
[in]namename of a model flag
[in]valuethe string to be assigned to the flag specified by name
Returns
a boolean that is true if the execution is successful

Reimplemented from QCD.

Reimplemented in LeftRightSymmetricModel, NPSMEFTd6General, THDM, and THDMW.

Definition at line 507 of file StandardModel/src/StandardModel.cpp.

508{
509 bool res = false;
510 if (name.compare("Mw") == 0) {
511 if (checkEWPOscheme(value)) {
512 FlagMw = value;
513 res = true;
514 } else
515 throw std::runtime_error("StandardModel::setFlagStr(): Invalid flag "
516 + name + "=" + value);
517
518 } else if (name.compare("RhoZ") == 0) {
519 if (checkEWPOscheme(value)) {
520 FlagRhoZ = value;
521 res = true;
522 } else
523 throw std::runtime_error("StandardModel::setFlagStr(): Invalid flag "
524 + name + "=" + value);
525 } else if (name.compare("KappaZ") == 0) {
526 if (checkEWPOscheme(value)) {
527 FlagKappaZ = value;
528 res = true;
529 } else
530 throw std::runtime_error("StandardModel::setFlagStr(): Invalid flag "
531 + name + "=" + value);
532 } else
533 res = QCD::setFlagStr(name, value);
534
535 if (FlagMWinput) {
536 // Point the different flags towards the approximate formulae, when available
538 FlagMw = "APPROXIMATEFORMULA";
539 FlagRhoZ = "NORESUM";
540 FlagKappaZ = "APPROXIMATEFORMULA";
541 }
542
543 return (res);
544}
virtual bool setFlagStr(const std::string name, const std::string value)
A method to set a flag of QCD.
Definition: QCD.cpp:511
bool checkEWPOscheme(const std::string scheme) const
A method to check if a given scheme name in string form is valid.

◆ setParameter()

void StandardModel::setParameter ( const std::string  name,
const double &  value 
)
protectedvirtual

A method to set the value of a parameter of StandardModel.

Parameters
[in]namename of a model parameter
[in]valuethe value to be assigned to the parameter specified by name

Reimplemented from QCD.

Reimplemented in NPDF2, HiggsChiral, HiggsKigen, NPEpsilons, NPEpsilons_pureNP, NPHiggs, NPSMEFT6dtopquark, NPSMEFTd6, NPSMEFTd6General, NPSMEFTd6U2, NPSMEFTd6U2qU1le, NPSMEFTd6U3, NPSTU, NPSTUVWXY, NPSTUZbbbarLR, NPZbbbar, NPZbbbarLinearized, SigmaBR, SUSY, THDM, CMFV, FlavourWilsonCoefficient, FlavourWilsonCoefficient_DF2, GeneralSUSY, GeorgiMachacek, LeftRightSymmetricModel, MFV, pMSSM, SUSYMassInsertion, and THDMW.

Definition at line 277 of file StandardModel/src/StandardModel.cpp.

278{
279 if (name.compare("Mz") == 0) {
280 Mz = value;
281 QCD::setParameter("MAls", value);
282 } else if (name.compare("AlsMz") == 0) {
283 AlsMz = value;
284 QCD::setParameter("AlsM", value);
285 } else if (name.compare("GF") == 0)
286 GF = value;
287 else if (name.compare("ale") == 0)
288 ale = value;
289 else if (name.compare("dAle5Mz") == 0 && !FlagMWinput)
290 dAle5Mz = value;
291 else if (name.compare("Mw_inp") == 0 && FlagMWinput)
292 Mw_inp = value;
293 else if (name.compare("mHl") == 0)
294 mHl = value;
295 else if (name.compare("delMw") == 0)
296 delMw = value;
297 else if (name.compare("delSin2th_l") == 0)
298 delSin2th_l = value;
299 else if (name.compare("delSin2th_q") == 0)
300 delSin2th_q = value;
301 else if (name.compare("delSin2th_b") == 0)
302 delSin2th_b = value;
303 else if (name.compare("delGammaZ") == 0)
304 delGammaZ = value;
305 else if (name.compare("delsigma0H") == 0)
306 delsigma0H = value;
307 else if (name.compare("delR0l") == 0)
308 delR0l = value;
309 else if (name.compare("delR0c") == 0)
310 delR0c = value;
311 else if (name.compare("delR0b") == 0)
312 delR0b = value;
313 else if (name.compare("mneutrino_1") == 0)
314 leptons[NEUTRINO_1].setMass(value);
315 else if (name.compare("mneutrino_2") == 0)
316 leptons[NEUTRINO_2].setMass(value);
317 else if (name.compare("mneutrino_3") == 0)
318 leptons[NEUTRINO_3].setMass(value);
319 else if (name.compare("melectron") == 0)
320 leptons[ELECTRON].setMass(value);
321 else if (name.compare("mmu") == 0)
322 leptons[MU].setMass(value);
323 else if (name.compare("mtau") == 0)
324 leptons[TAU].setMass(value);
325 else if (name.compare("lambda") == 0 && FlagWolfenstein) {
326 lambda = value;
327 requireCKM = true;
328 } else if (name.compare("A") == 0 && FlagWolfenstein) {
329 A = value;
330 requireCKM = true;
331 } else if (name.compare("rhob") == 0 && FlagWolfenstein) {
332 rhob = value;
333 requireCKM = true;
334 } else if (name.compare("etab") == 0 && FlagWolfenstein) {
335 etab = value;
336 requireCKM = true;
337 } else if (name.compare("V_us") == 0 && !FlagWolfenstein && !FlagUseVud) {
338 Vus = value;
339 requireCKM = true;
340 } else if (name.compare("V_ud") == 0 && !FlagWolfenstein && FlagUseVud) {
341 Vud = value;
342 requireCKM = true;
343 } else if (name.compare("V_cb") == 0 && !FlagWolfenstein) {
344 Vcb = value;
345 requireCKM = true;
346 } else if (name.compare("V_ub") == 0 && !FlagWolfenstein) {
347 Vub = value;
348 requireCKM = true;
349 } else if (name.compare("gamma") == 0 && !FlagWolfenstein) {
350 gamma = value;
351 requireCKM = true;
352 } else if (name.compare("muw") == 0) {
353 /* Update mut if FlagFixMuwMut is activated */
354 muw = value;
355 if (FlagFixMuwMut) {
356 mut = muw / 80.4 * 163.;
357 }
358 }
359 else
360 QCD::setParameter(name, value);
361}
void setMass(double mass)
A set method to fix the particle mass.
Definition: Particle.h:70
virtual void setParameter(const std::string name, const double &value)
A method to set the value of a parameter of QCD.
Definition: QCD.cpp:343

◆ setRequireCKM()

void StandardModel::setRequireCKM ( bool  requireCKM)
inline

A set method to change the value of requireCKM.

Parameters
[in]requireCKMthe new value for requireCKM

Definition at line 3319 of file StandardModel.h.

3320 {
3321 this->requireCKM = requireCKM;
3322 }

◆ setYd()

void StandardModel::setYd ( const gslpp::matrix< gslpp::complex > &  Yd)
inline

A set method to set the Yukawa matrix of the down-type quarks, \(Y_d\).

Parameters
[in]Ydthe Yukawa matrix to be set

Definition at line 3368 of file StandardModel.h.

3369 {
3370 this->Yd = Yd;
3371 }

◆ setYe()

void StandardModel::setYe ( const gslpp::matrix< gslpp::complex > &  Ye)
inline

A set method to set the Yukawa matrix of the charged leptons, \(Y_e\).

Parameters
[in]Yethe Yukawa matrix to be set

Definition at line 3388 of file StandardModel.h.

3389 {
3390 this->Ye = Ye;
3391 }

◆ setYu()

void StandardModel::setYu ( const gslpp::matrix< gslpp::complex > &  Yu)
inline

A set method to set the Yukawa matrix of the up-type quarks, \(Y_u\).

Parameters
[in]Yuthe Yukawa matrix to be set

Definition at line 3348 of file StandardModel.h.

3349 {
3350 this->Yu = Yu;
3351 }

◆ sigma0_had()

const double StandardModel::sigma0_had ( ) const
virtual

The hadronic cross section for \(e^+e^- \to Z \to \mathrm{hadrons}\) at the \(Z\)-pole, \(\sigma_h^0\).

When checkNPZff_linearized() returns true and the model flag NoApproximateGammaZ of StandardModel is set to false, this function uses the two-loop approximate formula of \(\sigma_h^0\) via EWSMApproximateFormulae::X_full_2_loop(). Otherwise, the hadronic cross section is calculated with

\[ \sigma_h^0 = \frac{12\pi}{M_Z^2}\frac{\Gamma_e\Gamma_h}{\Gamma_Z^2}\,. \]

Returns
\(\sigma_h^0\) in GeV \(^{-2}\)

Reimplemented in NPbase, NPEpsilons, NPSMEFTd6General, and NPZbbbar.

Definition at line 1464 of file StandardModel/src/StandardModel.cpp.

1465{
1467
1468 /* SM contribution with the approximate formula */
1469 return (myApproximateFormulae->X_full("sigmaHadron")
1470 / GeVminus2_to_nb);
1471
1472 } else {
1473 return (12.0 * M_PI * GammaZ(leptons[ELECTRON]) * Gamma_had()
1474 / Mz / Mz / Gamma_Z() / Gamma_Z());
1475 }
1476}
static const double GeVminus2_to_nb

◆ sigma_NoISR_l()

const double StandardModel::sigma_NoISR_l ( const QCD::lepton  l_flavor,
const double  s 
) const
protected

Definition at line 8000 of file StandardModel/src/StandardModel.cpp.

8001{
8002 double ml = getLeptons(l_flavor).getMass();
8003 double l_charge = getLeptons(l_flavor).getCharge();
8004 double sigma = myTwoFermionsLEP2->sigma_l(l_flavor, ml, s, Mw(), Gamma_Z(), flagLEP2[Weak]);
8005
8006 if (!bSigmaForAFB && flagLEP2[QEDFSR])
8007 sigma *= myTwoFermionsLEP2->QED_FSR_forSigma(s, l_charge);
8008
8009 return sigma;
8010}

◆ sigma_NoISR_q()

const double StandardModel::sigma_NoISR_q ( const QCD::quark  q_flavor,
const double  s 
) const
protected

Definition at line 8012 of file StandardModel/src/StandardModel.cpp.

8013{
8014 double mq = m_q(q_flavor, sqrt(s));
8015 double q_charge = getQuarks(q_flavor).getCharge();
8016 double sigma = myTwoFermionsLEP2->sigma_q(q_flavor, mq, s, Mw(), Gamma_Z(), flagLEP2[Weak]);
8017
8018 if (!bSigmaForAFB && flagLEP2[QEDFSR])
8019 sigma *= myTwoFermionsLEP2->QED_FSR_forSigma(s, q_charge);
8020
8021 if (!bSigmaForAFB && flagLEP2[QCDFSR])
8023
8024 return sigma;
8025}

◆ SigmaeeHee()

const double StandardModel::SigmaeeHee ( const double  sqrt_s,
const double  Pe,
const double  Pp 
) const
virtual

The \(\sigma(e^+ e^- \to e^+ e^- H)\) in the Standard Model.

Currently, only at tree level. From https://arxiv.org/pdf/hep-ph/9605437

Returns
\(\sigma(e^+ e^- \to e^+ e^- H)\) in the Standard Model

Definition at line 3350 of file StandardModel/src/StandardModel.cpp.

3351{
3352 double xsLH=0.0, xsRH=0.0;
3353
3354 return 0.25*( (1.0 - Pe)*(1.0 + Pp)*xsLH + (1.0 + Pe)*(1.0 - Pp)*xsRH );
3355}

◆ SigmaeeHvv()

const double StandardModel::SigmaeeHvv ( const double  sqrt_s,
const double  Pe,
const double  Pp 
) const
virtual

The \(\sigma(e^+ e^- \to \nu \bar{\nu} H)\) in the Standard Model.

Currently, only at tree level. From https://arxiv.org/pdf/hep-ph/9605437

Returns
\(\sigma(e^+ e^- \to \nu \bar{\nu} H)\) in the Standard Model

Definition at line 3343 of file StandardModel/src/StandardModel.cpp.

3344{
3345 double xsLH=1.0, xsRH=0.0;
3346
3347 return 0.25*( (1.0 - Pe)*(1.0 + Pp)*xsLH + (1.0 + Pe)*(1.0 - Pp)*xsRH );
3348}

◆ SigmaeeZH()

const double StandardModel::SigmaeeZH ( const double  sqrt_s,
const double  Pe,
const double  Pp 
) const
virtual

The \(\sigma(e^+ e^- \to Z H)\) in the Standard Model.

Currently, only at tree level. From https://arxiv.org/pdf/hep-ph/9605437

Returns
\(\sigma(e^+ e^- \to Z H)\) in the Standard Model

Definition at line 3321 of file StandardModel/src/StandardModel.cpp.

3322{
3323 double xsLH, xsRH;
3324 double gL,gR,lam,fact;
3325 double s = sqrt_s*sqrt_s;
3326
3327 // From https://arxiv.org/pdf/hep-ph/9605437
3328
3329 gL = -0.5 + sW2();
3330
3331 gR = sW2();
3332
3333 lam = (1.0-(mHl+Mz)*(mHl+Mz)/s)*(1.0-(mHl-Mz)*(mHl-Mz)/s);
3334
3335 fact = (pow(GF*Mz*Mz,2.0)/96.0/M_PI/s) * sqrt(lam)*( lam + 12.0*Mz*Mz/s )/( 1.0 - Mz*Mz/s )/( 1.0 - Mz*Mz/s );
3336
3337 xsLH = 32.0 * gL * gL * fact;
3338 xsRH = 32.0 * gR * gR * fact;
3339
3340 return 0.25*( (1.0 - Pe)*(1.0 + Pp)*xsLH + (1.0 + Pe)*(1.0 - Pp)*xsRH );
3341}

◆ sin2thetaEff()

const double StandardModel::sin2thetaEff ( const Particle  f) const
virtual

The effective weak mixing angle \(\sin^2\theta_{\rm eff}^{\,\ell}\) for \(Z\ell\bar{\ell}\) at the the \(Z\)-mass scale.

When checkNPZff_linearized() returns true and the model flag KappaZ of StandardModel is set to APPROXIMATEFORMULA, this function uses the two-loop approximate formula of \(\sin^2\theta_{\rm eff}^{\,\ell}\) via EWSMApproximateFormulae::sin2thetaEff(). Otherwise, the effective weak mixing angle is calculated from the coupling \(\kappa_Z^\ell\):

\[ \sin^2\theta_{\rm eff}^{\,\ell} = {\rm Re}(\kappa_Z^\ell)\,s_W^2\,. \]

Parameters
[in]fa lepton or quark
Returns
\(\sin^2\theta_{\rm eff}^{\,\ell}\)
Attention
\(\ell\) stands for both a neutrino and a charged lepton.

Reimplemented in NPbase, NPZbbbar, and NPEpsilons.

Definition at line 1350 of file StandardModel/src/StandardModel.cpp.

1351{
1352 double Re_kappa = kappaZ_f(f).real();
1353 return ( Re_kappa * sW2());
1354}

◆ sW2() [1/2]

const double StandardModel::sW2 ( ) const

Definition at line 1091 of file StandardModel/src/StandardModel.cpp.

1092{
1093 return ( 1.0 - cW2());
1094}

◆ sW2() [2/2]

const double StandardModel::sW2 ( const double  Mw_i) const
virtual

The square of the sine of the weak mixing angle in the on-shell scheme, denoted as \(s_W^2\).

\[ s_W^2=\sin^2{\theta_W}=1-\frac{M_W^2}{M_Z^2}. \]

Returns
\(s_W^2\)

Definition at line 1086 of file StandardModel/src/StandardModel.cpp.

1087{
1088 return ( 1.0 - cW2(Mw_i));
1089}

◆ sW2_MSbar_Approx()

const double StandardModel::sW2_MSbar_Approx ( ) const

The (approximated formula for the) square of the sine of the weak mixing angle in the MSbar scheme, denoted as \(\hat{s}_{W}^2\). See: PDG 22, R.L. Workman et al. (Particle Data Group), Prog. Theor. Exp. Phys. 2022, 083C01 (2022)

Returns
\(\hat{s}_{W}^2\)

Definition at line 1096 of file StandardModel/src/StandardModel.cpp.

1097{
1098 //double rho_t= 3. * getGF() * getMtpole() * getMtpole() / (8. * sqrt(2.) * M_PI * M_PI );
1099 return ( sW2()*1.0351 ); //PDG 22 electroweak review eq. (10.19)
1100}

◆ sW2_ND()

const double StandardModel::sW2_ND ( ) const

The square of the sine of the weak mixing angle in the MSbar-ND scheme (w/o decoupling $\alpha\ln(m_t/M_Z)$ terms), denoted as \(\hat{s}_{ND}^2\). See: PDG 22, R.L. Workman et al. (Particle Data Group), Prog. Theor. Exp. Phys. 2022, 083C01 (2022) (eq. 10.13a/10.13b)

Returns
\(\hat{s}_{ND}^2\)

Definition at line 1102 of file StandardModel/src/StandardModel.cpp.

1103{
1104 double d = 1. / 3. * (1. / sW2_MSbar_Approx() - 8. / 3.) *
1105 ( (1 + getAlsMz()/M_PI)*log(getMtpole()/getMz()) - 15.*getAlsMz()/(8.*M_PI) );
1106
1107 return sW2_MSbar_Approx()*(1. + Ale(getMz(),FULLNLO)*d/M_PI);
1108
1109}
const double getMtpole() const
A get method to access the pole mass of the top quark.
Definition: QCD.h:600
const double sW2_MSbar_Approx() const
The (approximated formula for the) square of the sine of the weak mixing angle in the MSbar scheme,...
const double getMz() const
A get method to access the mass of the boson .
const double getAlsMz() const
A get method to access the value of .

◆ taub()

double StandardModel::taub ( ) const
protected

Top-mass corrections to the \(Zb\bar{b}\) vertex, denoted by \(\tau_b\).

The large top-quark mass gives important corrections to the EW observables through the gauge-boson self-energies, i.e., \(\Delta\rho\), and through the \(Zb\bar{b}\) vertex. The latter contribution is parameterised by the quantity \(\tau_b\):

\[ \tau_{b} = -2\, X_t^{G_\mu} \left[ 1 - \frac{\pi}{3}\alpha_s(M^2_t) + X_t^{G_\mu} \tau^{(2)} \left( \frac{M_t^2}{m_h^2} \right) \right], \]

where the \(O(G_\mu\alpha_s m_t^2)\) term was calculated in [Fleischer:1992fq], [Buchalla:1992zm], [Degrassi:1993ij], [Chetyrkin:1993jp], and the \(O(G_\mu^2 m_t^4)\) term can be found in [Barbieri:1992nz], [Barbieri:1992dq], [Fleischer:1993ub], [Fleischer:1994cb].

Returns
\(\tau_b\)

Definition at line 2112 of file StandardModel/src/StandardModel.cpp.

2113{
2114 double taub_tmp = 0.0;
2115 double Xt = myEWSMcache->Xt_GF();
2116 if (flag_order[EW1])
2117 taub_tmp += -2.0 * Xt;
2118 if (flag_order[EW1QCD1])
2119 taub_tmp += 2.0 / 3.0 * M_PI * Xt * myEWSMcache->alsMt();
2120 if (flag_order[EW1QCD2])
2121 taub_tmp += 0.0;
2122 if (flag_order[EW2])
2123 taub_tmp += -2.0 * Xt * Xt * myTwoLoopEW->tau_2();
2124 if (flag_order[EW2QCD1])
2125 taub_tmp += 0.0;
2126 if (flag_order[EW3])
2127 taub_tmp += 0.0;
2128
2129 return taub_tmp;
2130}
double tau_2() const
The function .
double Xt_GF() const
The quantity with the coupling .
Definition: EWSMcache.h:343
double alsMt() const
The strong coupling at NNLO.
Definition: EWSMcache.h:378

◆ TauLFU_gmuge()

const double StandardModel::TauLFU_gmuge ( ) const
virtual

The computation of the LFU ratio \(g_\mu/ g_e \).

Returns
\(g_\mu/ g_e \)

Reimplemented in NPbase.

Definition at line 3164 of file StandardModel/src/StandardModel.cpp.

3165{
3166 double g2LFU;
3167
3168 double me, mmu, mtau, xe, Fxe, xmu, Fxmu;
3169
3170 me = leptons[ELECTRON].getMass();
3171 mmu = leptons[MU].getMass();
3172 mtau = leptons[TAU].getMass();
3173
3174 xe = me*me/mtau/mtau;
3175 Fxe = 1. - 8. * xe + 8. * xe*xe*xe - xe*xe*xe*xe -12. * xe*xe * log(xe);
3176
3177 xmu = mmu*mmu/mtau/mtau;
3178 Fxmu = 1. - 8. * xmu + 8. * xmu*xmu*xmu - xmu*xmu*xmu*xmu -12. * xmu*xmu * log(xmu);
3179
3181
3182 g2LFU = g2LFU * (Fxe/Fxmu);
3183
3184 return sqrt(g2LFU);
3185}
virtual const double Gamma_tau_l_nunu(const Particle l) const
The computation of the leptonic tau decays.

◆ TauLFU_gtauge()

const double StandardModel::TauLFU_gtauge ( ) const
virtual

The computation of the LFU ratio \(g_\tau/ g_e \).

Returns
\(g_\tau/ g_e \)

Reimplemented in NPbase.

Definition at line 3210 of file StandardModel/src/StandardModel.cpp.

3211{
3212 double g2LFU;
3213
3214 double me, mmu, mtau, xtau, Fxtau, xmu, Fxmu;
3215
3216 me = leptons[ELECTRON].getMass();
3217 mmu = leptons[MU].getMass();
3218 mtau = leptons[TAU].getMass();
3219
3220 xtau = mmu*mmu/mtau/mtau;
3221 Fxtau = 1. - 8. * xtau + 8. * xtau*xtau*xtau - xtau*xtau*xtau*xtau -12. * xtau*xtau * log(xtau);
3222
3223 xmu = me*me/mmu/mmu;
3224 Fxmu = 1. - 8. * xmu + 8. * xmu*xmu*xmu - xmu*xmu*xmu*xmu -12. * xmu*xmu * log(xmu);
3225
3226 g2LFU = (Gamma_tau_l_nunu(leptons[MU])/Gamma_muon());
3227
3228 g2LFU = g2LFU * (pow(mmu,5)*Fxmu/pow(mtau,5)/Fxtau);
3229
3230 return sqrt(g2LFU);
3231}
virtual const double Gamma_muon() const
The computation of the muon decay.

◆ TauLFU_gtaugmu()

const double StandardModel::TauLFU_gtaugmu ( ) const
virtual

The computation of the LFU ratio \(g_\tau/ g_\mu \).

Returns
\(g_\tau/ g_\mu \)

Reimplemented in NPbase.

Definition at line 3187 of file StandardModel/src/StandardModel.cpp.

3188{
3189 double g2LFU;
3190
3191 double me, mmu, mtau, xtau, Fxtau, xmu, Fxmu;
3192
3193 me = leptons[ELECTRON].getMass();
3194 mmu = leptons[MU].getMass();
3195 mtau = leptons[TAU].getMass();
3196
3197 xtau = me*me/mtau/mtau;
3198 Fxtau = 1. - 8. * xtau + 8. * xtau*xtau*xtau - xtau*xtau*xtau*xtau -12. * xtau*xtau * log(xtau);
3199
3200 xmu = me*me/mmu/mmu;
3201 Fxmu = 1. - 8. * xmu + 8. * xmu*xmu*xmu - xmu*xmu*xmu*xmu -12. * xmu*xmu * log(xmu);
3202
3204
3205 g2LFU = g2LFU * (pow(mmu,5)*Fxmu/pow(mtau,5)/Fxtau);
3206
3207 return sqrt(g2LFU);
3208}

◆ TauLFU_gtaugmuK()

const double StandardModel::TauLFU_gtaugmuK ( ) const
virtual

The computation of the LFU ratio \(\left(g_\tau/ g_\mu\right)_K \).

Returns
\(\left(g_\tau/ g_\mu\right)_K \)

Reimplemented in NPbase.

Definition at line 3241 of file StandardModel/src/StandardModel.cpp.

3242{
3243 // 1st approx.
3244
3245 return 1.0;
3246}

◆ TauLFU_gtaugmuPi()

const double StandardModel::TauLFU_gtaugmuPi ( ) const
virtual

The computation of the LFU ratio \(\left(g_\tau/ g_\mu\right)_\pi \).

Returns
\(\left(g_\tau/ g_\mu\right)_\pi \)

Reimplemented in NPbase.

Definition at line 3234 of file StandardModel/src/StandardModel.cpp.

3235{
3236 // 1st approx.
3237
3238 return 1.0;
3239}

◆ ThetaLnuN()

const double StandardModel::ThetaLnuN ( ) const
virtual

The effective neutrino nucleon LH parameter: ThetaLnuN.

Follows the corresponding semianalytical expression in EWSMApproximateFormulae.

Returns
\(\theta_L(\nu N)\)

Definition at line 3027 of file StandardModel/src/StandardModel.cpp.

3028{
3029 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
3031
3032 /* SM contribution with the approximate formula */
3034
3035 } else {
3036 throw std::runtime_error("ERROR: StandardModel::ThetaLnuN, prediction implemented only via semianalytical approximate formula. Check flags!");
3037 }
3038}
double LEThetaLnuNApprox() const
The effective neutrino nucleon LH parameter: ThetaLnuN.

◆ ThetaRnuN()

const double StandardModel::ThetaRnuN ( ) const
virtual

The effective neutrino nucleon RH parameter: ThetaRnuN.

Follows the corresponding semianalytical expression in EWSMApproximateFormulae.

Returns
\(\theta_R(\nu N)\)

Definition at line 3041 of file StandardModel/src/StandardModel.cpp.

3042{
3043 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
3045
3046 /* SM contribution with the approximate formula */
3048
3049 } else {
3050 throw std::runtime_error("ERROR: StandardModel::ThetaRnuN, prediction implemented only via semianalytical approximate formula. Check flags!");
3051 }
3052}
double LEThetaRnuNApprox() const
The effective neutrino nucleon RH parameter: ThetaRnuN.

◆ tovers2()

const double StandardModel::tovers2 ( const double  cosmin,
const double  cosmax 
) const

Definition at line 3911 of file StandardModel/src/StandardModel.cpp.

3911 {
3912 return 0.25 * (cosmax * (1.0 - cosmax * (1.0 - cosmax / 3.0)) - cosmin * (1.0 - cosmin * (1.0 - cosmin / 3.0)));
3913}

◆ uovers2()

const double StandardModel::uovers2 ( const double  cosmin,
const double  cosmax 
) const

Definition at line 3915 of file StandardModel/src/StandardModel.cpp.

3915 {
3916 return 0.25 * (cosmax * (1.0 + cosmax * (1.0 + cosmax / 3.0)) - cosmin * (1.0 + cosmin * (1.0 + cosmin / 3.0)));
3917}

◆ Update()

bool StandardModel::Update ( const std::map< std::string, double > &  DPars)
virtual

The update method for StandardModel.

This method updates all the model parameters with given DPars.

Parameters
[in]DParsa map of the parameters that are being updated in the Monte Carlo run (including parameters that are varied and those that are held constant)
Returns
a boolean that is true if the execution is successful

Reimplemented from QCD.

Reimplemented in FlavourWilsonCoefficient, LoopMediators, RealWeakEFTCC, RealWeakEFTLFV, GeneralSUSY, GeorgiMachacek, LeftRightSymmetricModel, MFV, NPbase, pMSSM, SUSY, SUSYMassInsertion, THDM, and THDMW.

Definition at line 225 of file StandardModel/src/StandardModel.cpp.

226{
227 if (!PreUpdate()) return (false);
228
229 UpdateError = false;
230
231 for (std::map<std::string, double>::const_iterator it = DPars.begin(); it != DPars.end(); it++)
232 setParameter(it->first, it->second);
233
234 if (UpdateError) return (false);
235
236 if (!PostUpdate()) return (false);
237
238 return (true);
239}
bool UpdateError
A boolean set to false if update is successful.
Definition: Model.h:272
virtual bool PreUpdate()
The pre-update method for StandardModel.
virtual bool PostUpdate()
The post-update method for StandardModel.
virtual void setParameter(const std::string name, const double &value)
A method to set the value of a parameter of StandardModel.

◆ v()

const double StandardModel::v ( ) const

The Higgs vacuum expectation value.

\[ v = \left(\frac{1}{\sqrt{2} G_\mu}\right)^{1/2}, \]

where \(G_\mu\) is the Fermi constant, measured through muon decays.

Returns
\(v\) in GeV

Definition at line 988 of file StandardModel/src/StandardModel.cpp.

989{
990 return ( 1. / sqrt(sqrt(2.) * GF));
991}

Member Data Documentation

◆ A

double StandardModel::A
protected

The CKM parameter \(A\) in the Wolfenstein parameterization.

Definition at line 3444 of file StandardModel.h.

◆ ale

double StandardModel::ale
protected

The fine-structure constant \(\alpha\).

Definition at line 3431 of file StandardModel.h.

◆ ale_cache

double StandardModel::ale_cache[10][CacheSize]
mutableprivate

Cache for \(\alpha_e\).

Definition at line 4060 of file StandardModel.h.

◆ alpha21

double StandardModel::alpha21
protected

Definition at line 3453 of file StandardModel.h.

◆ alpha31

double StandardModel::alpha31
protected

Definition at line 3453 of file StandardModel.h.

◆ als_cache

double StandardModel::als_cache[11][CacheSize]
mutableprivate

Cache for \(\alpha_s\).

Definition at line 4059 of file StandardModel.h.

◆ AlsMz

double StandardModel::AlsMz
protected

The strong coupling constant at the Z-boson mass, \(\alpha_s(M_Z)\).

Definition at line 3427 of file StandardModel.h.

◆ average

double StandardModel::average
mutableprivate

GSL integral variable

Definition at line 4045 of file StandardModel.h.

◆ bSigmaForAFB

bool StandardModel::bSigmaForAFB
mutableprotected

Definition at line 3711 of file StandardModel.h.

◆ bSigmaForR

bool StandardModel::bSigmaForR
mutableprotected

Definition at line 3712 of file StandardModel.h.

◆ CacheSize

const int StandardModel::CacheSize = 5
staticprivate

Defines the depth of the cache.

Definition at line 4058 of file StandardModel.h.

◆ dAl5hMz

double StandardModel::dAl5hMz
protected

The five-flavour hadronic contribution to the electromagnetic coupling, \(\Delta\alpha_{\mathrm{had}}^{(5)}(M_Z^2)\). (Non-input parameter)

Definition at line 3456 of file StandardModel.h.

◆ dAle5Mz

double StandardModel::dAle5Mz
protected

The five-flavour hadronic contribution to the electromagnetic coupling, \(\Delta\alpha_{\mathrm{had}}^{(5)}(M_Z^2)\), used as input for FlagMWinput = FALSE.

Definition at line 3432 of file StandardModel.h.

◆ delGammaZ

double StandardModel::delGammaZ
protected

The theoretical uncertainty in \(\Gamma_Z\), denoted as \(\delta\,\Gamma_Z\), in GeV.

Definition at line 3438 of file StandardModel.h.

◆ delMw

double StandardModel::delMw
protected

The theoretical uncertainty in \(M_W\), denoted as \(\delta\,M_W\), in GeV.

Definition at line 3434 of file StandardModel.h.

◆ delR0b

double StandardModel::delR0b
protected

The theoretical uncertainty in \(R_b^0\), denoted as \(\delta\,R_b^0\).

Definition at line 3442 of file StandardModel.h.

◆ delR0c

double StandardModel::delR0c
protected

The theoretical uncertainty in \(R_c^0\), denoted as \(\delta\,R_c^0\).

Definition at line 3441 of file StandardModel.h.

◆ delR0l

double StandardModel::delR0l
protected

The theoretical uncertainty in \(R_l^0\), denoted as \(\delta\,R_l^0\).

Definition at line 3440 of file StandardModel.h.

◆ delsigma0H

double StandardModel::delsigma0H
protected

The theoretical uncertainty in \(\sigma_{Hadron}^0\), denoted as \(\delta\,\sigma_{Hadron}^0\) in nb.

Definition at line 3439 of file StandardModel.h.

◆ delSin2th_b

double StandardModel::delSin2th_b
protected

The theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{b}\), denoted as \(\delta\sin^2\theta_{\rm eff}^{b}\).

Definition at line 3437 of file StandardModel.h.

◆ delSin2th_l

double StandardModel::delSin2th_l
protected

The theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{\rm lept}\), denoted as \(\delta\sin^2\theta_{\rm eff}^{\rm lept}\).

Definition at line 3435 of file StandardModel.h.

◆ delSin2th_q

double StandardModel::delSin2th_q
protected

The theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{q\not = b,t}\), denoted as \(\delta\sin^2\theta_{\rm eff}^{q\not = b,t}\).

Definition at line 3436 of file StandardModel.h.

◆ delta

double StandardModel::delta
protected

Definition at line 3453 of file StandardModel.h.

◆ DeltaAlpha_cache

double StandardModel::DeltaAlpha_cache
mutableprivate

A cache of the value of \(\Delta\alpha(M_Z^2)\).

Definition at line 4026 of file StandardModel.h.

◆ DeltaAlphaLepton_cache

double StandardModel::DeltaAlphaLepton_cache
mutableprivate

A cache of the value of \(\Delta\alpha_{\mathrm{lept}}(M_Z^2)\).

Definition at line 4025 of file StandardModel.h.

◆ error

double StandardModel::error
mutableprivate

GSL integral variable

Definition at line 4046 of file StandardModel.h.

◆ etab

double StandardModel::etab
protected

The CKM parameter \(\bar{\eta}\) in the Wolfenstein parameterization.

Definition at line 3446 of file StandardModel.h.

◆ f_GSL

gsl_function StandardModel::f_GSL
mutableprivate

GSL integral variable

Definition at line 4047 of file StandardModel.h.

◆ flag_order

bool StandardModel::flag_order[orders_EW_size]
protected

An array of internal flags controlling the inclusions of higher-order corrections.

These flags are prepared for debugging. The flags are initialized in the constructor EWSM().

Definition at line 3467 of file StandardModel.h.

◆ FlagCacheInStandardModel

bool StandardModel::FlagCacheInStandardModel
private

A flag for caching (true by default).

Definition at line 4023 of file StandardModel.h.

◆ FlagFixMuwMut

bool StandardModel::FlagFixMuwMut
protected

A boolean for the model flag FixMuwMut.

Definition at line 3701 of file StandardModel.h.

◆ FlagKappaZ

std::string StandardModel::FlagKappaZ
private

A string for the model flag KappaZ.

Definition at line 4013 of file StandardModel.h.

◆ flagLEP2

bool StandardModel::flagLEP2[NUMofLEP2RCs]
protected

Definition at line 3710 of file StandardModel.h.

◆ FlagMw

std::string StandardModel::FlagMw
private

A string for the model flag Mw.

Definition at line 4011 of file StandardModel.h.

◆ FlagMWinput

bool StandardModel::FlagMWinput
private

A boolean for the model flag MWinput.

Definition at line 4017 of file StandardModel.h.

◆ FlagNoApproximateGammaZ

bool StandardModel::FlagNoApproximateGammaZ
private

A boolean for the model flag NoApproximateGammaZ.

Definition at line 4010 of file StandardModel.h.

◆ FlagRhoZ

std::string StandardModel::FlagRhoZ
private

A string for the model flag RhoZ.

Definition at line 4012 of file StandardModel.h.

◆ FlagSMAux

bool StandardModel::FlagSMAux
private

A boolean for the model flag SMAux.

Definition at line 4018 of file StandardModel.h.

◆ FlagUseVud

bool StandardModel::FlagUseVud
private

A boolean for the model flag UseVud.

Definition at line 4015 of file StandardModel.h.

◆ FlagWithoutNonUniversalVC

bool StandardModel::FlagWithoutNonUniversalVC
private

A boolean for the model flag WithoutNonUniversalVC.

Definition at line 4009 of file StandardModel.h.

◆ FlagWolfenstein

bool StandardModel::FlagWolfenstein
private

A boolean for the model flag Wolfenstein.

Definition at line 4014 of file StandardModel.h.

◆ gamma

double StandardModel::gamma
protected

\(\gamma \) used as an input for FlagWolfenstein = FALSE

Definition at line 3451 of file StandardModel.h.

◆ GammaW_cache

double StandardModel::GammaW_cache
mutableprivate

A cache of the value of \(\Gamma_W\).

Definition at line 4028 of file StandardModel.h.

◆ GeVminus2_to_nb

const double StandardModel::GeVminus2_to_nb = 389379.338
static

Definition at line 546 of file StandardModel.h.

◆ GF

double StandardModel::GF
protected

The Fermi constant \(G_\mu\) in \({\rm GeV}^{-2}\).

Definition at line 3430 of file StandardModel.h.

◆ iterationNo

int StandardModel::iterationNo
private

Definition at line 4051 of file StandardModel.h.

◆ kappaZ_f_cache

gslpp::complex StandardModel::kappaZ_f_cache[12]
mutableprivate

A cache of the value of \(\kappa_Z^l\).

Definition at line 4030 of file StandardModel.h.

◆ lambda

double StandardModel::lambda
protected

The CKM parameter \(\lambda\) in the Wolfenstein parameterization.

Definition at line 3443 of file StandardModel.h.

◆ leptons

Particle StandardModel::leptons[6]
protected

An array of Particle objects for the leptons.

Definition at line 3414 of file StandardModel.h.

◆ mHl

double StandardModel::mHl
protected

The Higgs mass \(m_h\) in GeV.

Definition at line 3433 of file StandardModel.h.

◆ muw

double StandardModel::muw
protected

A matching scale \(\mu_W\) around the weak scale in GeV.

Definition at line 3452 of file StandardModel.h.

◆ Mw_cache

double StandardModel::Mw_cache
mutableprivate

A cache of the value of \(M_W\).

Definition at line 4027 of file StandardModel.h.

◆ Mw_error

const double StandardModel::Mw_error = 0.00001
static

The target accuracy of the iterative calculation of the \(W\)-boson mass in units of GeV.

Definition at line 552 of file StandardModel.h.

◆ Mw_inp

double StandardModel::Mw_inp
protected

The mass of the \(W\) boson in GeV used as input for FlagMWinput = TRUE.

Definition at line 3429 of file StandardModel.h.

◆ myApproximateFormulae

EWSMApproximateFormulae* StandardModel::myApproximateFormulae
private

A pointer to an object of type EWSMApproximateFormulae.

Definition at line 4003 of file StandardModel.h.

◆ myCKM

CKM StandardModel::myCKM
protected

An object of type CKM.

Definition at line 3415 of file StandardModel.h.

◆ myEWSMcache

EWSMcache* StandardModel::myEWSMcache
private

A pointer to an object of type EWSMcache.

Definition at line 3996 of file StandardModel.h.

◆ myLeptonFlavour

LeptonFlavour* StandardModel::myLeptonFlavour
private

A pointer to an object of the type LeptonFlavour.

Definition at line 4004 of file StandardModel.h.

◆ myOneLoopEW

EWSMOneLoopEW* StandardModel::myOneLoopEW
private

A pointer to an object of type EWSMOneLoopEW.

Definition at line 3997 of file StandardModel.h.

◆ myPMNS

PMNS StandardModel::myPMNS
protected

Definition at line 3416 of file StandardModel.h.

◆ myThreeLoopEW

EWSMThreeLoopEW* StandardModel::myThreeLoopEW
private

A pointer to an object of type EWSMThreeLoopEW.

Definition at line 4002 of file StandardModel.h.

◆ myThreeLoopEW2QCD

EWSMThreeLoopEW2QCD* StandardModel::myThreeLoopEW2QCD
private

A pointer to an object of type EWSMThreeLoopEW2QCD.

Definition at line 4001 of file StandardModel.h.

◆ myThreeLoopQCD

EWSMThreeLoopQCD* StandardModel::myThreeLoopQCD
private

A pointer to an object of type EWSMThreeLoopQCD.

Definition at line 3999 of file StandardModel.h.

◆ myTwoFermionsLEP2

EWSMTwoFermionsLEP2* StandardModel::myTwoFermionsLEP2
private

A pointer to an object of type EWSMTwoFermionsLEP2.

Definition at line 4006 of file StandardModel.h.

◆ myTwoLoopEW

EWSMTwoLoopEW* StandardModel::myTwoLoopEW
private

A pointer to an object of type EWSMTwoLoopEW.

Definition at line 4000 of file StandardModel.h.

◆ myTwoLoopQCD

EWSMTwoLoopQCD* StandardModel::myTwoLoopQCD
private

A pointer to an object of type EWSMTwoLoopQCD.

Definition at line 3998 of file StandardModel.h.

◆ Mz

double StandardModel::Mz
protected

The mass of the \(Z\) boson in GeV.

Definition at line 3428 of file StandardModel.h.

◆ NSMvars

const int StandardModel::NSMvars = 26
static

The number of the model parameters in StandardModel.

Definition at line 540 of file StandardModel.h.

◆ NumSMParamsForEWPO

const int StandardModel::NumSMParamsForEWPO = 33
static

The number of the SM parameters that are relevant to the EW precision observables.

This constant is used for the cashing method.

See also
checkSMparamsForEWPO()

Definition at line 2100 of file StandardModel.h.

◆ realorder

orders StandardModel::realorder
mutableprivate

Definition at line 4061 of file StandardModel.h.

◆ requireCKM

bool StandardModel::requireCKM
protected

An internal flag to control whether the CKM matrix has to be recomputed.

Definition at line 3696 of file StandardModel.h.

◆ requireYe

bool StandardModel::requireYe
protected

An internal flag to control whether the charged-lepton Yukawa matrix has to be recomputed.

Definition at line 3697 of file StandardModel.h.

◆ requireYn

bool StandardModel::requireYn
protected

An internal flag to control whether the neutrino Yukawa matrix has to be recomputed.

Definition at line 3698 of file StandardModel.h.

◆ rhob

double StandardModel::rhob
protected

The CKM parameter \(\bar{\rho}\) in the Wolfenstein parameterization.

Definition at line 3445 of file StandardModel.h.

◆ rhoZ_f_cache

gslpp::complex StandardModel::rhoZ_f_cache[12]
mutableprivate

A cache of the value of \(\rho_Z^l\).

Definition at line 4029 of file StandardModel.h.

◆ s12

double StandardModel::s12
protected

Definition at line 3453 of file StandardModel.h.

◆ s13

double StandardModel::s13
protected

Definition at line 3453 of file StandardModel.h.

◆ s23

double StandardModel::s23
protected

Definition at line 3453 of file StandardModel.h.

◆ SMFlavour

Flavour StandardModel::SMFlavour
protected

An object of type Flavour.

Definition at line 3700 of file StandardModel.h.

◆ SMM

Matching<StandardModelMatching,StandardModel> StandardModel::SMM
mutableprotected

An object of type Matching.

Definition at line 3419 of file StandardModel.h.

◆ SMparamsForEWPO_cache

double StandardModel::SMparamsForEWPO_cache[NumSMParamsForEWPO]
mutableprivate

Definition at line 4024 of file StandardModel.h.

◆ SMresult_cache

double StandardModel::SMresult_cache
mutableprivate

Definition at line 4041 of file StandardModel.h.

◆ SMvars

std::string StandardModel::SMvars
static
Initial value:
= {
"lambda", "A", "rhob", "etab", "Mz", "AlsMz", "GF", "ale", "dAle5Mz", "mHl",
"delMw", "delSin2th_l", "delSin2th_q", "delSin2th_b", "delGammaZ", "delsigma0H", "delR0l", "delR0c", "delR0b",
"mneutrino_1", "mneutrino_2", "mneutrino_3", "melectron", "mmu", "mtau", "muw"
}

A string array containing the labels of the model parameters in StandardModel.

Definition at line 544 of file StandardModel.h.

◆ useDeltaAlpha_cache

bool StandardModel::useDeltaAlpha_cache
mutableprivate

Definition at line 4032 of file StandardModel.h.

◆ useDeltaAlphaLepton_cache

bool StandardModel::useDeltaAlphaLepton_cache
mutableprivate

Definition at line 4031 of file StandardModel.h.

◆ useGammaW_cache

bool StandardModel::useGammaW_cache
mutableprivate

Definition at line 4034 of file StandardModel.h.

◆ useKappaZ_f_cache

bool StandardModel::useKappaZ_f_cache[12]
mutableprivate

Definition at line 4036 of file StandardModel.h.

◆ useMw_cache

bool StandardModel::useMw_cache
mutableprivate

Definition at line 4033 of file StandardModel.h.

◆ useRhoZ_f_cache

bool StandardModel::useRhoZ_f_cache[12]
mutableprivate

Definition at line 4035 of file StandardModel.h.

◆ Vcb

double StandardModel::Vcb
protected

\(\vert V_{cb} \vert \) used as an input for FlagWolfenstein = FALSE

Definition at line 3449 of file StandardModel.h.

◆ Vub

double StandardModel::Vub
protected

\(\vert V_{ub} \vert \) used as an input for FlagWolfenstein = FALSE

Definition at line 3450 of file StandardModel.h.

◆ Vud

double StandardModel::Vud
protected

\(\vert V_{ud} \vert \) used as an input for FlagWolfenstein = FALSE and FlagUseVud = TRUE

Definition at line 3448 of file StandardModel.h.

◆ Vus

double StandardModel::Vus
protected

\(\vert V_{us} \vert \) used as an input for FlagWolfenstein = FALSE

Definition at line 3447 of file StandardModel.h.

◆ w_GSL1

gsl_integration_workspace* StandardModel::w_GSL1
private

GSL integral variable

Definition at line 4048 of file StandardModel.h.

◆ Yd

gslpp::matrix<gslpp::complex> StandardModel::Yd
protected

The Yukawa matrix of the down-type quarks.

Definition at line 3421 of file StandardModel.h.

◆ Ye

gslpp::matrix<gslpp::complex> StandardModel::Ye
protected

The Yukawa matrix of the charged leptons.

Definition at line 3423 of file StandardModel.h.

◆ Yn

gslpp::matrix<gslpp::complex> StandardModel::Yn
protected

The Yukawa matrix of the neutrinos.

Definition at line 3422 of file StandardModel.h.

◆ Yu

gslpp::matrix<gslpp::complex> StandardModel::Yu
protected

The Yukawa matrix of the up-type quarks.

Definition at line 3420 of file StandardModel.h.


The documentation for this class was generated from the following files: